rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces using // or %r around regular expressions.
+      # Enforces using `//` or `%r` around regular expressions.
+      #
+      # NOTE: The following `%r` cases using a regexp starts with a blank or `=`
+      # as a method argument allowed to prevent syntax errors.
+      #
+      # [source,ruby]
+      # ----
+      # do_something %r{ regexp} # `do_something / regexp/` is an invalid syntax.
+      # do_something %r{=regexp} # `do_something /=regexp/` is an invalid syntax.
+      # ----
       #
       # @example EnforcedStyle: slashes (default)
       #   # bad
@@ -107,24 +116,21 @@ module RuboCop
         private
 
         def allowed_slash_literal?(node)
-          style == :slashes && !contains_disallowed_slash?(node) ||
-            allowed_mixed_slash?(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)
+          style == :mixed && node.single_line? && !contains_disallowed_slash?(node)
         end
 
         def allowed_percent_r_literal?(node)
-          style == :slashes && contains_disallowed_slash?(node) ||
+          (style == :slashes && contains_disallowed_slash?(node)) ||
             style == :percent_r ||
-            allowed_mixed_percent_r?(node)
+            allowed_mixed_percent_r?(node) || allowed_omit_parentheses_with_percent_r_literal?(node)
         end
 
         def allowed_mixed_percent_r?(node)
-          style == :mixed && node.multiline? ||
-            contains_disallowed_slash?(node)
+          (style == :mixed && node.multiline?) || contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)
@@ -149,8 +155,16 @@ module RuboCop
         end
 
         def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%r'].split(//)
+          config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']['%r'].chars
+        end
+
+        def allowed_omit_parentheses_with_percent_r_literal?(node)
+          return false unless node.parent&.call_type?
+          return true if node.content.start_with?(' ', '=')
+
+          enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
+
+          enforced_style == 'omit_parentheses'
         end
 
         def correct_delimiters(node, corrector)

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Sort `require` and `require_relative` in alphabetical order.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it will obviously change the execution order.
+      #
+      # @example
+      #   # bad
+      #   require 'b'
+      #   require 'a'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #
+      #   # bad
+      #   require_relative 'b'
+      #   require_relative 'a'
+      #
+      #   # good
+      #   require_relative 'a'
+      #   require_relative 'b'
+      #
+      #   # good (sorted within each section separated by a blank line)
+      #   require 'a'
+      #   require 'd'
+      #
+      #   require 'b'
+      #   require 'c'
+      #
+      #   # good
+      #   require 'b'
+      #   require_relative 'c'
+      #   require 'a'
+      #
+      #   # bad
+      #   require 'a'
+      #   require 'c' if foo
+      #   require 'b'
+      #
+      #   # good
+      #   require 'a'
+      #   require 'b'
+      #   require 'c' if foo
+      #
+      #   # bad
+      #   require 'c'
+      #   if foo
+      #     require 'd'
+      #     require 'b'
+      #   end
+      #   require 'a'
+      #
+      #   # good
+      #   require 'c'
+      #   if foo
+      #     require 'b'
+      #     require 'd'
+      #   end
+      #   require 'a'
+      #
+      class RequireOrder < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        MSG = 'Sort `%<name>s` in alphabetical order.'
+
+        # @!method if_inside_only_require(node)
+        def_node_matcher :if_inside_only_require, <<~PATTERN
+          {
+            (if _ _ $(send nil? {:require :require_relative} _))
+            (if _ $(send nil? {:require :require_relative} _) _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless node.parent && node.arguments?
+          return if not_modifier_form?(node.parent)
+
+          previous_older_sibling = find_previous_older_sibling(node)
+          return unless previous_older_sibling
+
+          add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
+            autocorrect(corrector, node, previous_older_sibling)
+          end
+        end
+
+        private
+
+        def not_modifier_form?(node)
+          node.if_type? && !node.modifier_form?
+        end
+
+        def find_previous_older_sibling(node) # rubocop:disable Metrics
+          search_node(node).left_siblings.reverse.find do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
+            sibling = sibling_node(sibling)
+            break unless sibling&.send_type? && sibling.method?(node.method_name)
+            break unless sibling.arguments? && !sibling.receiver
+            break unless in_same_section?(sibling, node)
+            break unless node.first_argument.str_type? && sibling.first_argument.str_type?
+
+            node.first_argument.value < sibling.first_argument.value
+          end
+        end
+
+        def autocorrect(corrector, node, previous_older_sibling)
+          range1 = range_with_comments_and_lines(previous_older_sibling)
+          range2 = range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
+
+          corrector.remove(range2)
+          corrector.insert_before(range1, range2.source)
+        end
+
+        def search_node(node)
+          node.parent.if_type? ? node.parent : node
+        end
+
+        def sibling_node(node)
+          return if not_modifier_form?(node)
+
+          node.if_type? ? if_inside_only_require(node) : node
+        end
+
+        def in_same_section?(node1, node2)
+          !node1.source_range.join(node2.source_range.end).source.include?("\n\n")
+        end
+      end
+    end
+  end
+end

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

@@ -3,13 +3,11 @@
 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
+      # Checks for uses of `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
+      #   might lead 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.
@@ -39,23 +37,27 @@ module RuboCop
       #   rescue SomeException
       #     handle_error
       #   end
-      class RescueModifier < Cop
+      class RescueModifier < Base
         include Alignment
+        include RangeHelp
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_resbody(node)
           return unless rescue_modifier?(node)
 
-          add_offense(node.parent)
-        end
+          rescue_node = node.parent
+          add_offense(rescue_node) do |corrector|
+            parenthesized = parenthesized?(rescue_node)
 
-        def autocorrect(node)
-          parenthesized = parenthesized?(node)
-          lambda do |corrector|
-            corrector.replace(node, corrected_block(node, parenthesized))
-            ParenthesesCorrector.correct(corrector, node.parent) if parenthesized
+            correct_rescue_block(corrector, rescue_node, parenthesized)
+            ParenthesesCorrector.correct(corrector, rescue_node.parent) if parenthesized
           end
         end
 
@@ -65,18 +67,23 @@ module RuboCop
           node.parent && parentheses?(node.parent)
         end
 
-        def corrected_block(node, parenthesized)
-          operation, rescue_modifier, = *node
-          *_, rescue_args = *rescue_modifier
+        # rubocop:disable Metrics/AbcSize
+        def correct_rescue_block(corrector, node, parenthesized)
+          operation = node.body
 
           node_indentation, node_offset = indentation_and_offset(node, parenthesized)
 
-          "begin\n" \
-            "#{operation.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}rescue\n" \
-            "#{rescue_args.source.gsub(/^/, node_indentation)}" \
-            "\n#{node_offset}end"
+          corrector.wrap(operation, '[', ']') if operation.array_type? && !operation.bracketed?
+          corrector.remove(range_between(operation.source_range.end_pos, node.source_range.end_pos))
+          corrector.insert_before(operation, "begin\n#{node_indentation}")
+          corrector.insert_after(heredoc_end(operation) || operation, <<~RESCUE_CLAUSE.chop)
+
+            #{node_offset}rescue
+            #{node_indentation}#{node.resbody_branches.first.body.source}
+            #{node_offset}end
+          RESCUE_CLAUSE
         end
+        # rubocop:enable Metrics/AbcSize
 
         def indentation_and_offset(node, parenthesized)
           node_indentation = indentation(node)
@@ -87,6 +94,18 @@ module RuboCop
           end
           [node_indentation, node_offset]
         end
+
+        def heredoc_end(node)
+          return unless node.call_type?
+
+          heredoc = node.arguments.reverse.find do |argument|
+            argument.respond_to?(:heredoc?) && argument.heredoc?
+          end
+
+          return unless heredoc
+
+          heredoc.loc.heredoc_end
+        end
       end
     end
   end

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

@@ -3,25 +3,25 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for rescuing `StandardError`. There are two supported
+      # Checks for rescuing `StandardError`. There are two supported
       # styles `implicit` and `explicit`. This cop will not register an offense
       # if any error other than `StandardError` is specified.
       #
-      # @example EnforcedStyle: implicit
-      #   # `implicit` will enforce using `rescue` instead of
-      #   # `rescue StandardError`.
+      # @example EnforcedStyle: explicit (default)
+      #   # `explicit` will enforce using `rescue StandardError`
+      #   # instead of `rescue`.
       #
       #   # bad
       #   begin
       #     foo
-      #   rescue StandardError
+      #   rescue
       #     bar
       #   end
       #
       #   # good
       #   begin
       #     foo
-      #   rescue
+      #   rescue StandardError
       #     bar
       #   end
       #
@@ -39,21 +39,21 @@ module RuboCop
       #     bar
       #   end
       #
-      # @example EnforcedStyle: explicit (default)
-      #   # `explicit` will enforce using `rescue StandardError`
-      #   # instead of `rescue`.
+      # @example EnforcedStyle: implicit
+      #   # `implicit` will enforce using `rescue` instead of
+      #   # `rescue StandardError`.
       #
       #   # bad
       #   begin
       #     foo
-      #   rescue
+      #   rescue StandardError
       #     bar
       #   end
       #
       #   # good
       #   begin
       #     foo
-      #   rescue StandardError
+      #   rescue
       #     bar
       #   end
       #
@@ -76,15 +76,15 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_IMPLICIT = 'Omit the error class when rescuing ' \
-          '`StandardError` by itself.'
-        MSG_EXPLICIT = 'Avoid rescuing without specifying ' \
-          'an error class.'
+        MSG_IMPLICIT = 'Omit the error class when rescuing `StandardError` by itself.'
+        MSG_EXPLICIT = 'Avoid rescuing without specifying an error class.'
 
+        # @!method rescue_without_error_class?(node)
         def_node_matcher :rescue_without_error_class?, <<~PATTERN
           (resbody nil? _ _)
         PATTERN
 
+        # @!method rescue_standard_error?(node)
         def_node_matcher :rescue_standard_error?, <<~PATTERN
           (resbody $(array (const {nil? cbase} :StandardError)) _ _)
         PATTERN
@@ -98,26 +98,24 @@ module RuboCop
               offense_for_implicit_enforced_style(node, error)
             end
           when :explicit
-            rescue_without_error_class?(node) do
-              offense_for_exlicit_enforced_style(node)
-            end
+            rescue_without_error_class?(node) { offense_for_explicit_enforced_style(node) }
           end
         end
 
         private
 
         def offense_for_implicit_enforced_style(node, error)
-          range = node.loc.keyword.join(error.loc.expression)
+          range = node.loc.keyword.join(error.source_range)
 
           add_offense(range, message: MSG_IMPLICIT) do |corrector|
             error = rescue_standard_error?(node)
-            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+            range = range_between(node.loc.keyword.end_pos, error.source_range.end_pos)
 
             corrector.remove(range)
           end
         end
 
-        def offense_for_exlicit_enforced_style(node)
+        def offense_for_explicit_enforced_style(node)
           add_offense(node.loc.keyword, message: MSG_EXPLICIT) do |corrector|
             corrector.insert_after(node.loc.keyword, ' StandardError')
           end

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between `return nil` and `return`.
       #
-      # Supported styles are: return, return_nil.
+      # This cop is disabled by default. Because there seems to be a perceived semantic difference
+      # between `return` and `return nil`. The former can be seen as just halting evaluation,
+      # while the latter might be used when the return value is of specific concern.
+      #
+      # Supported styles are `return` and `return_nil`.
       #
       # @example EnforcedStyle: return (default)
       #   # bad
@@ -35,12 +39,15 @@ module RuboCop
         RETURN_MSG = 'Use `return` instead of `return nil`.'
         RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'
 
+        # @!method return_node?(node)
         def_node_matcher :return_node?, '(return)'
+
+        # @!method return_nil_node?(node)
         def_node_matcher :return_nil_node?, '(return nil)'
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
-          node.each_ancestor(:block, :def, :defs) do |n|
+          node.each_ancestor(:block, :any_def) do |n|
             break if scoped_node?(n)
 
             send_node, args_node, _body_node = *n
@@ -71,15 +78,18 @@ module RuboCop
         end
 
         def correct_style?(node)
-          style == :return && !return_nil_node?(node) ||
-            style == :return_nil && !return_node?(node)
+          (style == :return && !return_nil_node?(node)) ||
+            (style == :return_nil && !return_node?(node))
         end
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
+        # @!method chained_send?(node)
         def_node_matcher :chained_send?, '(send !nil? ...)'
+
+        # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN
           (send _ {:define_method :define_singleton_method} _)
         PATTERN

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for predicate method definitions that return `nil`.
+      # A predicate method should only return a boolean value.
+      #
+      # @safety
+      #   Autocorrection is marked as unsafe because the change of the return value
+      #   from `nil` to `false` could potentially lead to incompatibility issues.
+      #
+      # @example
+      #   # bad
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # bad
+      #   def foo?
+      #     return nil if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     return false if condition
+      #
+      #     do_something?
+      #   end
+      #
+      #   # bad
+      #   def foo?
+      #     if condition
+      #       nil
+      #     else
+      #       true
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo?
+      #     if condition
+      #       false
+      #     else
+      #       true
+      #     end
+      #   end
+      #
+      # @example AllowedMethods: ['foo?']
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedPatterns: [/foo/]
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      class ReturnNilInPredicateMethodDefinition < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Return `false` instead of `nil` in predicate methods.'
+
+        # @!method return_nil?(node)
+        def_node_matcher :return_nil?, <<~PATTERN
+          {(return) (return (nil))}
+        PATTERN
+
+        def on_def(node)
+          return unless node.predicate_method?
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return unless (body = node.body)
+
+          body.each_descendant(:return) { |return_node| handle_return(return_node) }
+
+          handle_implicit_return_values(body)
+        end
+        alias on_defs on_def
+
+        private
+
+        def last_node_of_type(node, type)
+          return unless node
+          return node if node_type?(node, type)
+          return unless node.begin_type?
+          return unless (last_child = node.children.last)
+
+          last_child if last_child.is_a?(AST::Node) && node_type?(last_child, type)
+        end
+
+        def node_type?(node, type)
+          node.type == type.to_sym
+        end
+
+        def register_offense(offense_node, replacement)
+          add_offense(offense_node) do |corrector|
+            corrector.replace(offense_node, replacement)
+          end
+        end
+
+        def handle_implicit_return_values(node)
+          handle_if(last_node_of_type(node, :if))
+          handle_nil(last_node_of_type(node, :nil))
+        end
+
+        def handle_return(return_node)
+          register_offense(return_node, 'return false') if return_nil?(return_node)
+        end
+
+        def handle_nil(nil_node)
+          return unless nil_node
+
+          register_offense(nil_node, 'false')
+        end
+
+        def handle_if(if_node)
+          return unless if_node
+
+          handle_implicit_return_values(if_node.if_branch)
+          handle_implicit_return_values(if_node.else_branch)
+        end
+      end
+    end
+  end
+end