rubocop 1.36.0 → 1.40.0

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

@@ -44,7 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if allowed_escape?(node, char, index, within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +65,21 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessry to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          node.source[index] == '[' || node.source[index + 3] == ']'
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 

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

@@ -53,6 +53,13 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+
+        def on_send(node)
+          return unless (parent = node.parent) && parent.block_type?
+
+          check_branch(parent.body)
+        end
 
         def on_def(node)
           check_branch(node.body)

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

@@ -184,7 +184,7 @@ module RuboCop
         end
 
         def arg_value(node)
-          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+          arg_node(node)&.node_parts&.first
         end
 
         # This gets the start of the accessor whether it has a dot

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant escapes in string literals.
+      #
+      # @example
+      #   # bad - no need to escape # without following {/$/@
+      #   "\#foo"
+      #
+      #   # bad - no need to escape single quotes inside double quoted string
+      #   "\'foo\'"
+      #
+      #   # bad - heredocs are also checked for unnecessary escapes
+      #   <<~STR
+      #     \#foo \"foo\"
+      #   STR
+      #
+      #   # good
+      #   "#foo"
+      #
+      #   # good
+      #   "\#{no_interpolation}"
+      #
+      #   # good
+      #   "'foo'"
+      #
+      #   # good
+      #   "foo\
+      #   bar"
+      #
+      #   # good
+      #   <<~STR
+      #     #foo "foo"
+      #   STR
+      class RedundantStringEscape < Base
+        include MatchRange
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant escape of %<char>s inside string literal.'
+
+        def on_str(node)
+          return if node.parent&.regexp_type? || node.parent&.xstr_type? || node.character_literal?
+
+          str_contents_range = str_contents_range(node)
+
+          each_match_range(str_contents_range, /(\\.)/) do |range|
+            next if allowed_escape?(node, range.resize(3))
+
+            add_offense(range) do |corrector|
+              corrector.remove_leading(range, 1)
+            end
+          end
+        end
+
+        private
+
+        def message(range)
+          format(MSG, char: range.source.chars.last)
+        end
+
+        def str_contents_range(node)
+          if heredoc?(node)
+            node.loc.heredoc_body
+          elsif begin_loc_present?(node)
+            contents_range(node)
+          else
+            node.loc.expression
+          end
+        end
+
+        def begin_loc_present?(node)
+          # e.g. a __FILE__ literal has no begin loc so we can't query if it's nil
+          node.loc.to_hash.key?(:begin) && !node.loc.begin.nil?
+        end
+
+        def allowed_escape?(node, range)
+          escaped = range.source[(1..-1)]
+
+          # Inside a single-quoted string, escapes (except \\ and \') do not have special meaning,
+          # and so are not redundant, as they are a literal backslash.
+          return true if interpolation_not_enabled?(node)
+
+          # Strictly speaking a few single-letter chars are currently unnecessary to "escape", e.g.
+          # d, but enumerating them is rather difficult, and their behavior could change over time
+          # with different versions of Ruby so that e.g. /\d/ != /d/
+          return true if /[\n\\[[:alnum:]]]/.match?(escaped[0])
+
+          return true if escaped[0] == ' ' && percent_array_literal?(node)
+
+          return true if disabling_interpolation?(range)
+          return true if delimiter?(node, escaped[0])
+
+          false
+        end
+
+        def interpolation_not_enabled?(node)
+          single_quoted?(node) ||
+            percent_w_literal?(node) ||
+            percent_q_literal?(node) ||
+            heredoc_with_disabled_interpolation?(node)
+        end
+
+        def single_quoted?(node)
+          delimiter?(node, "'")
+        end
+
+        def percent_q_literal?(node)
+          if literal_in_interpolated_or_multiline_string?(node)
+            percent_q_literal?(node.parent)
+          else
+            node.source.start_with?('%q')
+          end
+        end
+
+        def array_literal?(node, prefix)
+          if literal_in_interpolated_or_multiline_string?(node)
+            array_literal?(node.parent, prefix)
+          else
+            node.parent&.array_type? && node.parent.source.start_with?(prefix)
+          end
+        end
+
+        def percent_w_literal?(node)
+          array_literal?(node, '%w')
+        end
+
+        def percent_w_upper_literal?(node)
+          array_literal?(node, '%W')
+        end
+
+        def percent_array_literal?(node)
+          (percent_w_literal?(node) || percent_w_upper_literal?(node))
+        end
+
+        def heredoc_with_disabled_interpolation?(node)
+          if heredoc?(node)
+            node.loc.expression.source.end_with?("'")
+          elsif node.parent&.dstr_type?
+            heredoc_with_disabled_interpolation?(node.parent)
+          else
+            false
+          end
+        end
+
+        def heredoc?(node)
+          (node.str_type? || node.dstr_type?) && node.heredoc?
+        end
+
+        def delimiter?(node, char)
+          return false if heredoc?(node)
+
+          if literal_in_interpolated_or_multiline_string?(node) || percent_array_literal?(node)
+            return delimiter?(node.parent, char)
+          end
+
+          delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
+
+          delimiters.include?(char)
+        end
+
+        def literal_in_interpolated_or_multiline_string?(node)
+          node.str_type? && !begin_loc_present?(node) && node.parent&.dstr_type?
+        end
+
+        def disabling_interpolation?(range)
+          # Allow \#{foo}, \#$foo, \#@foo, and \#@@foo
+          # for escaping local, global, instance and class variable interpolations
+          return true if range.source.match?(/\A\\#[{$@]/)
+
+          # Also allow #\{foo}, #\$foo, #\@foo and #\@@foo
+          return true if range.adjust(begin_pos: -2).source.match?(/\A[^\\]#\\[{$@]/)
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# 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'
+      class RequireOrder < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
+
+        def on_send(node)
+          previous_older_sibling = find_previous_older_sibling(node)
+          return unless previous_older_sibling
+
+          add_offense(
+            node,
+            message: "Sort `#{node.method_name}` in alphabetical order."
+          ) do |corrector|
+            swap(
+              range_with_comments_and_lines(previous_older_sibling),
+              range_with_comments_and_lines(node),
+              corrector: corrector
+            )
+          end
+        end
+
+        private
+
+        def find_previous_older_sibling(node)
+          node.left_siblings.reverse.find do |sibling|
+            break unless sibling.send_type?
+            break unless sibling.method?(node.method_name)
+            break unless in_same_section?(sibling, node)
+
+            node.first_argument.source < sibling.first_argument.source
+          end
+        end
+
+        def in_same_section?(node1, node2)
+          !node1.location.expression.with(
+            end_pos: node2.location.expression.end_pos
+          ).source.include?("\n\n")
+        end
+
+        def swap(range1, range2, corrector:)
+          inserted = range2.source
+          corrector.insert_before(range1, inserted)
+          corrector.remove(range2)
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ module RuboCop
       # 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.

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

@@ -50,6 +50,11 @@ module RuboCop
       #   foo && foo.bar { |e| e.something }
       #   foo && foo.bar(param) { |e| e.something }
       #
+      #   foo ? foo.bar : nil
+      #   foo.nil? ? nil : foo.bar
+      #   !foo.nil? ? foo.bar : nil
+      #   !foo ? nil : foo.bar
+      #
       #   # good
       #   foo&.bar
       #   foo&.bar&.baz
@@ -105,6 +110,17 @@ module RuboCop
           }
         PATTERN
 
+        # @!method ternary_safe_navigation_candidate(node)
+        def_node_matcher :ternary_safe_navigation_candidate, <<~PATTERN
+          {
+            (if (send $_ {:nil? :!}) nil $_)
+
+            (if (send (send $_ :nil?) :!) $_ nil)
+
+            (if $_ $_ nil)
+          }
+        PATTERN
+
         # @!method not_nil_check?(node)
         def_node_matcher :not_nil_check?, '(send (send $_ :nil?) :!)'
 
@@ -118,9 +134,11 @@ module RuboCop
           check_node(node)
         end
 
+        private
+
         def check_node(node)
           checked_variable, receiver, method_chain, method = extract_parts(node)
-          return unless receiver == checked_variable
+          return if receiver != checked_variable || receiver.nil?
           return if use_var_only_in_unless_modifier?(node, checked_variable)
           return if chain_length(method_chain, method) > max_chain_length
           return if unsafe_method_used?(method_chain, method)
@@ -133,10 +151,8 @@ module RuboCop
           node.if_type? && node.unless? && !method_called?(variable)
         end
 
-        private
-
         def autocorrect(corrector, node)
-          body = node.node_parts[1]
+          body = extract_body(node)
           method_call = method_call(node)
 
           corrector.remove(begin_range(node, body))
@@ -147,6 +163,14 @@ module RuboCop
           add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
         end
 
+        def extract_body(node)
+          if node.if_type? && node.ternary?
+            node.branches.find { |branch| !branch.nil_type? }
+          else
+            node.node_parts[1]
+          end
+        end
+
         def handle_comments(corrector, node, method_call)
           comments = comments(node)
           return if comments.empty?
@@ -174,7 +198,7 @@ module RuboCop
         end
 
         def allowed_if_condition?(node)
-          node.else? || node.elsif? || node.ternary?
+          node.else? || node.elsif?
         end
 
         def method_call(node)
@@ -192,7 +216,12 @@ module RuboCop
         end
 
         def extract_parts_from_if(node)
-          variable, receiver = modifier_if_safe_navigation_candidate(node)
+          variable, receiver =
+            if node.ternary?
+              ternary_safe_navigation_candidate(node)
+            else
+              modifier_if_safe_navigation_candidate(node)
+            end
 
           checked_variable, matching_receiver, method = extract_common_parts(receiver, variable)
 

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

@@ -49,7 +49,8 @@ module RuboCop
         MSG = 'Prefer `%<replacement>s` to `%<original_method>s` with a regexp match.'
         RESTRICT_ON_SEND = %i[select find_all reject].freeze
         REPLACEMENTS = { select: 'grep', find_all: 'grep', reject: 'grep_v' }.freeze
-        REGEXP_METHODS = %i[match? =~].to_set.freeze
+        OPPOSITE_REPLACEMENTS = { select: 'grep_v', find_all: 'grep_v', reject: 'grep' }.freeze
+        REGEXP_METHODS = %i[match? =~ !~].to_set.freeze
 
         # @!method regexp_match?(node)
         def_node_matcher :regexp_match?, <<~PATTERN
@@ -90,8 +91,10 @@ module RuboCop
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
+          opposite = regexp_method_send_node.send_type? && regexp_method_send_node.method?(:!~)
           regexp = find_regexp(regexp_method_send_node, block_node)
-          register_offense(node, block_node, regexp)
+
+          register_offense(node, block_node, regexp, opposite)
         end
 
         private
@@ -102,8 +105,9 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp)
-          replacement = REPLACEMENTS[node.method_name.to_sym]
+        def register_offense(node, block_node, regexp, opposite)
+          method_name = node.method_name.to_sym
+          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|

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

@@ -44,18 +44,49 @@ module RuboCop
       #   end
       #
       class StaticClass < Base
+        include RangeHelp
         include VisibilityHelp
+        extend AutoCorrector
 
         MSG = 'Prefer modules to classes with only class methods.'
 
         def on_class(class_node)
           return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
 
-          add_offense(class_node) if class_convertible_to_module?(class_node)
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
         end
 
         private
 
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
         def class_convertible_to_module?(class_node)
           nodes = class_elements(class_node)
           return false if nodes.empty?

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

@@ -95,11 +95,7 @@ module RuboCop
         end
 
         def offense?(node)
-          # If it's a string within an interpolation, then it's not an offense
-          # for this cop.
-          return false if inside_interpolation?(node)
-
-          wrong_quotes?(node)
+          wrong_quotes?(node) && !inside_interpolation?(node)
         end
 
         def consistent_multiline?

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

@@ -65,6 +65,8 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           syms = node.children.map do |c|
             if c.dsym_type?
               string_literal = to_string_literal(c.source)

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

@@ -7,7 +7,7 @@ module RuboCop
       #
       # If you prefer a style that allows block for method with arguments,
       # please set `true` to `AllowMethodsWithArguments`.
-      # respond_to , and `define_method?` methods are allowed by default.
+      # `define_method?` methods are allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
       # @safety
@@ -72,17 +72,15 @@ module RuboCop
       #     # some comment
       #   end
       #
-      # @example AllowedMethods: [respond_to, define_method] (default)
+      # @example AllowedMethods: [define_method] (default)
       #   # good
-      #   respond_to { |foo| foo.bar }
       #   define_method(:foo) { |foo| foo.bar }
       #
-      #
       # @example AllowedPatterns: [] (default)
       #   # bad
       #   something.map { |s| s.upcase }
       #
-      # @example AllowedPatterns: [/map/] (default)
+      # @example AllowedPatterns: ['map'] (default)
       #   # good
       #   something.map { |s| s.upcase }
       #

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

@@ -83,6 +83,8 @@ module RuboCop
         end
 
         def build_bracketed_array(node)
+          return '[]' if node.children.empty?
+
           words = node.children.map do |word|
             if word.dstr_type?
               string_literal = to_string_literal(word.source)

data/lib/rubocop/cop/team.rb

@@ -38,12 +38,11 @@ module RuboCop
         new(cops, config, options)
       end
 
-      # @return [Array<Cop::Cop>]
+      # @return [Array<Cop::Base>]
       def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.enabled(config).map do |cop_class|
           cop_class.new(config, options)
         end
       end

data/lib/rubocop/cop/util.rb

@@ -122,7 +122,7 @@ module RuboCop
           string.inspect
         else
           # In a single-quoted strings, double quotes don't need to be escaped
-          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 
@@ -159,7 +159,7 @@ module RuboCop
       private
 
       def compatible_external_encoding_for?(src)
-        src = src.dup if RUBY_VERSION < '2.3' || RUBY_ENGINE == 'jruby'
+        src = src.dup if RUBY_ENGINE == 'jruby'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
     end

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
+          grandparent_node = node.parent&.parent
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def accessible_variables
-          scope_stack.reverse_each.each_with_object([]) do |scope, variables|
+          scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
             break variables unless scope.node.block_type?
           end