rubocop 1.50.2 → 1.54.1

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies usages of `any?`, `empty?` or `none?` predicate methods
+      # chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
+      #
+      # @example
+      #   # bad
+      #   arr.select { |x| x > 1 }.any?
+      #
+      #   # good
+      #   arr.any? { |x| x > 1 }
+      #
+      #   # bad
+      #   arr.select { |x| x > 1 }.empty?
+      #   arr.select { |x| x > 1 }.none?
+      #
+      #   # good
+      #   arr.none? { |x| x > 1 }
+      #
+      #   # good
+      #   relation.select(:name).any?
+      #   arr.select { |x| x > 1 }.any?(&:odd?)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   arr.select { |x| x > 1 }.many?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   arr.select { |x| x > 1 }.many?
+      #
+      #   # good
+      #   arr.many? { |x| x > 1 }
+      #
+      class RedundantFilterChain < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
+
+        RAILS_METHODS = %i[many?].freeze
+        RESTRICT_ON_SEND = (%i[any? empty? none? one?] + RAILS_METHODS).freeze
+
+        # @!method select_predicate?(node)
+        def_node_matcher :select_predicate?, <<~PATTERN
+          (send
+            {
+              (block $(send _ {:select :filter :find_all}) ...)
+              $(send _ {:select :filter :find_all} block_pass_type?)
+            }
+            ${:#{RESTRICT_ON_SEND.join(' :')}})
+        PATTERN
+
+        REPLACEMENT_METHODS = {
+          any?: :any?,
+          empty?: :none?,
+          none?: :none?,
+          one?: :one?,
+          many?: :many?
+        }.freeze
+        private_constant :REPLACEMENT_METHODS
+
+        def on_send(node)
+          return if node.arguments? || node.block_node
+
+          select_predicate?(node) do |select_node, filter_method|
+            return if RAILS_METHODS.include?(filter_method) && !active_support_extensions_enabled?
+
+            register_offense(select_node, node)
+          end
+        end
+
+        private
+
+        def register_offense(select_node, predicate_node)
+          replacement = REPLACEMENT_METHODS[predicate_node.method_name]
+          message = format(MSG, prefer: replacement,
+                                first_method: select_node.method_name,
+                                second_method: predicate_node.method_name)
+
+          offense_range = offense_range(select_node, predicate_node)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(predicate_range(predicate_node))
+            corrector.replace(select_node.loc.selector, replacement)
+          end
+        end
+
+        def offense_range(select_node, predicate_node)
+          select_node.loc.selector.join(predicate_node.loc.selector)
+        end
+
+        def predicate_range(predicate_node)
+          predicate_node.receiver.source_range.end.join(predicate_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -70,6 +70,10 @@ module RuboCop
 
         MSG = 'Redundant line continuation.'
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
+        ARGUMENT_TYPES = %i[
+          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
+          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+        ].freeze
 
         def on_new_investigation
           return unless processed_source.ast
@@ -112,7 +116,7 @@ module RuboCop
           return false if argument_newline?(node)
 
           source = node.parent ? node.parent.source : node.source
-          parse(source.gsub(/\\\n/, "\n")).valid_syntax?
+          parse(source.gsub("\\\n", "\n")).valid_syntax?
         end
 
         def inside_string_literal?(range, token)
@@ -124,7 +128,7 @@ module RuboCop
         #   do_something \
         #     argument
         def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && next_token.type == :tIDENTIFIER
+          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
         end
 
         def argument_newline?(node)
@@ -146,7 +150,7 @@ module RuboCop
         end
 
         def same_line?(node, line)
-          return unless (source_range = node.source_range)
+          return false unless (source_range = node.source_range)
 
           if node.is_a?(AST::StrNode)
             if node.heredoc?

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

@@ -85,7 +85,7 @@ module RuboCop
         end
 
         def allowed_ternary?(node)
-          return unless node&.parent&.if_type?
+          return false unless node&.parent&.if_type?
 
           node.parent.ternary? && ternary_parentheses_required?
         end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Identifies places where argument can be replaced from
+      # a deterministic regexp to a string.
+      #
+      # @example
+      #   # bad
+      #   'foo'.byteindex(/f/)
+      #   'foo'.byterindex(/f/)
+      #   'foo'.gsub(/f/, 'x')
+      #   'foo'.gsub!(/f/, 'x')
+      #   'foo'.partition(/f/)
+      #   'foo'.rpartition(/f/)
+      #   'foo'.scan(/f/)
+      #   'foo'.split(/f/)
+      #   'foo'.start_with?(/f/)
+      #   'foo'.sub(/f/, 'x')
+      #   'foo'.sub!(/f/, 'x')
+      #
+      #   # good
+      #   'foo'.byteindex('f')
+      #   'foo'.byterindex('f')
+      #   'foo'.gsub('f', 'x')
+      #   'foo'.gsub!('f', 'x')
+      #   'foo'.partition('f')
+      #   'foo'.rpartition('f')
+      #   'foo'.scan('f')
+      #   'foo'.split('f')
+      #   'foo'.start_with?('f')
+      #   'foo'.sub('f', 'x')
+      #   'foo'.sub!('f', 'x')
+      class RedundantRegexpArgument < Base
+        extend AutoCorrector
+
+        MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
+        RESTRICT_ON_SEND = %i[
+          byteindex byterindex gsub gsub! partition rpartition scan split start_with? sub sub!
+        ].freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
+        STR_SPECIAL_CHARS = %w[
+          \a \c \C \e \f \M \n \" \' \\\\ \t \b \f \r \u \v \x \0 \1 \2 \3 \4 \5 \6 \7
+        ].freeze
+
+        def on_send(node)
+          return unless (regexp_node = node.first_argument)
+          return unless regexp_node.regexp_type?
+          return if !regexp_node.regopt.children.empty? || regexp_node.content == ' '
+          return unless determinist_regexp?(regexp_node)
+
+          prefer = preferred_argument(regexp_node)
+          message = format(MSG, prefer: prefer, current: regexp_node.source)
+
+          add_offense(regexp_node, message: message) do |corrector|
+            corrector.replace(regexp_node, prefer)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def determinist_regexp?(regexp_node)
+          DETERMINISTIC_REGEX.match?(regexp_node.source)
+        end
+
+        def preferred_argument(regexp_node)
+          new_argument = replacement(regexp_node)
+
+          if new_argument.include?('"')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          else
+            quote = '"'
+          end
+
+          "#{quote}#{new_argument}#{quote}"
+        end
+
+        def replacement(regexp_node)
+          regexp_content = regexp_node.content
+          stack = []
+          chars = regexp_content.chars.each_with_object([]) do |char, strings|
+            if stack.empty? && char == '\\'
+              stack.push(char)
+            else
+              strings << "#{stack.pop}#{char}"
+            end
+          end
+          chars.map do |char|
+            char = char.dup
+            char.delete!('\\') unless STR_SPECIAL_CHARS.include?(char)
+            char
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for the instantiation of regexp using redundant `Regexp.new` or `Regexp.compile`.
+      # Autocorrect replaces to regexp literal which is the simplest and fastest.
+      #
+      # @example
+      #
+      #   # bad
+      #   Regexp.new(/regexp/)
+      #   Regexp.compile(/regexp/)
+      #
+      #   # good
+      #   /regexp/
+      #   Regexp.new('regexp')
+      #   Regexp.compile('regexp')
+      #
+      class RedundantRegexpConstructor < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant `Regexp.%<method>s`.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method redundant_regexp_constructor(node)
+        def_node_matcher :redundant_regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            (regexp $... (regopt $...)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp, regopt = redundant_regexp_constructor(node))
+
+          add_offense(node, message: format(MSG, method: node.method_name)) do |corrector|
+            pattern = regexp.map(&:source).join
+            regopt = regopt.join
+
+            corrector.replace(node, "/#{pattern}/#{regopt}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,8 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, index, within_character_class)
+            next if char.valid_encoding? && allowed_escape?(node, char, index,
+                                                            within_character_class)
 
             location = escape_range_at_index(node, index)
 

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

@@ -62,7 +62,9 @@ module RuboCop
         end
 
         def multiple_statements?(branch)
-          branch && branch.children.compact.count > 1
+          return false unless branch&.begin_type?
+
+          !branch.children.empty?
         end
 
         def self_assign?(variable, branch)

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

@@ -198,7 +198,7 @@ module RuboCop
         end
 
         def with_logical_operator?(node)
-          return unless (parent = node.parent)
+          return false unless (parent = node.parent)
 
           parent.or_type? || parent.and_type?
         end

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

@@ -157,6 +157,8 @@ module RuboCop
             return delimiter?(node.parent, char)
           end
 
+          return true unless node.loc.begin
+
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 
           delimiters.include?(char)

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

@@ -3,7 +3,16 @@
 module RuboCop
   module Cop
     module Style
-      # 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
@@ -151,7 +160,7 @@ module RuboCop
 
         def allowed_omit_parentheses_with_percent_r_literal?(node)
           return false unless node.parent&.call_type?
-          return true if node.content.start_with?(' ')
+          return true if node.content.start_with?(' ', '=')
 
           enforced_style = config.for_cop('Style/MethodCallWithArgsParentheses')['EnforcedStyle']
 

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

@@ -88,10 +88,7 @@ module RuboCop
           return unless previous_older_sibling
 
           add_offense(node, message: format(MSG, name: node.method_name)) do |corrector|
-            corrector.swap(
-              range_with_comments_and_lines(previous_older_sibling),
-              range_with_comments_and_lines(node.parent.if_type? ? node.parent : node)
-            )
+            autocorrect(corrector, node, previous_older_sibling)
           end
         end
 
@@ -109,11 +106,20 @@ module RuboCop
             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.source < sibling.first_argument.source
+            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

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

@@ -3,9 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # 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

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if `return` or `return nil` is used in predicate method definitions.
+      #
+      # @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
+      #
+      # @example AllowedMethod: ['foo?']
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      # @example AllowedPattern: [/foo/]
+      #   # good
+      #   def foo?
+      #     return if condition
+      #
+      #     do_something?
+      #   end
+      #
+      class ReturnNilInPredicateMethodDefinition < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+
+        MSG = 'Use `return false` instead of `%<prefer>s` in the predicate method.'
+
+        # @!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) do |return_node|
+            next unless return_nil?(return_node)
+
+            message = format(MSG, prefer: return_node.source)
+
+            add_offense(return_node, message: message) do |corrector|
+              corrector.replace(return_node, 'return false')
+            end
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -84,6 +84,7 @@ module RuboCop
           }
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           return unless (block_node = node.block_node)
           return if block_node.body&.begin_type?
@@ -91,11 +92,14 @@ module RuboCop
           return unless (regexp_method_send_node = extract_send_node(block_node))
           return if match_predicate_without_receiver?(regexp_method_send_node)
 
-          opposite = opposite?(regexp_method_send_node)
+          replacement = replacement(regexp_method_send_node, node)
+          return if target_ruby_version <= 2.2 && replacement == 'grep_v'
+
           regexp = find_regexp(regexp_method_send_node, block_node)
 
-          register_offense(node, block_node, regexp, opposite)
+          register_offense(node, block_node, regexp, replacement)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
@@ -105,9 +109,15 @@ module RuboCop
           node.hash_type? || creates_hash?(node) || env_const?(node)
         end
 
-        def register_offense(node, block_node, regexp, opposite)
-          method_name = node.method_name.to_sym
-          replacement = opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        def replacement(regexp_method_send_node, node)
+          opposite = opposite?(regexp_method_send_node)
+
+          method_name = node.method_name
+
+          opposite ? OPPOSITE_REPLACEMENTS[method_name] : REPLACEMENTS[method_name]
+        end
+
+        def register_offense(node, block_node, regexp, replacement)
           message = format(MSG, replacement: replacement, original_method: node.method_name)
 
           add_offense(block_node, message: message) do |corrector|

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

@@ -90,8 +90,11 @@ module RuboCop
             0
           elsif exist_semicolon_before_right_curly_brace?(tokens)
             -3
-          elsif exist_semicolon_after_left_curly_brace?(tokens)
+          elsif exist_semicolon_after_left_curly_brace?(tokens) ||
+                exist_semicolon_after_left_string_interpolation_brace?(tokens)
             2
+          elsif exist_semicolon_before_right_string_interpolation_brace?(tokens)
+            -4
           end
         end
 
@@ -103,6 +106,14 @@ module RuboCop
           tokens[1]&.left_curly_brace? && tokens[2]&.semicolon?
         end
 
+        def exist_semicolon_before_right_string_interpolation_brace?(tokens)
+          tokens[-3]&.type == :tSTRING_DEND && tokens[-4]&.semicolon?
+        end
+
+        def exist_semicolon_after_left_string_interpolation_brace?(tokens)
+          tokens[1]&.type == :tSTRING_DBEG && tokens[2]&.semicolon?
+        end
+
         def register_semicolon(line, column, after_expression, token_before_semicolon = nil)
           range = source_range(processed_source.buffer, line, column)
 

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

@@ -198,7 +198,7 @@ module RuboCop
         end
 
         def command_or_kernel_call?(name, node)
-          return unless node.method?(name)
+          return false unless node.method?(name)
 
           node.command?(name) || kernel_call?(node, name)
         end

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

@@ -135,7 +135,7 @@ module RuboCop
 
         def disallow_endless_method_style?
           endless_method_config = config.for_cop('Style/EndlessMethod')
-          return false unless endless_method_config['Enabled']
+          return true unless endless_method_config['Enabled']
 
           endless_method_config['EnforcedStyle'] == 'disallow'
         end

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

@@ -186,7 +186,9 @@ module RuboCop
           begin_pos = condition.first_argument.source_range.begin_pos
           return if end_pos > begin_pos
 
-          corrector.replace(range_between(end_pos, begin_pos), '(')
+          range = range_between(end_pos, begin_pos)
+          corrector.remove(range)
+          corrector.insert_after(range, '(')
           corrector.insert_after(condition.last_argument, ')')
         end
 

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

@@ -3,8 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      #
-      # This cop looks for uses of Perl-style global variables.
+      # Looks for uses of Perl-style global variables.
       # Correcting to global variables in the 'English' library
       # will add a require statement to the top of the file if
       # enabled by RequireEnglish config.
@@ -234,9 +233,9 @@ module RuboCop
         end
 
         def matching_styles(global)
-          STYLE_VARS_MAP.map do |style, vars|
+          STYLE_VARS_MAP.filter_map do |style, vars|
             style if vars.values.flatten(1).include? global
-          end.compact
+          end
         end
 
         def english_name_replacement(preferred_name, node)