rubocop 1.31.1 → 1.51.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for using empty heredoc to reduce redundancy.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<~EOS
+      #   EOS
+      #
+      #   <<-EOS
+      #   EOS
+      #
+      #   <<EOS
+      #   EOS
+      #
+      #   # good
+      #   ''
+      #
+      #   # bad
+      #   do_something(<<~EOS)
+      #   EOS
+      #
+      #   do_something(<<-EOS)
+      #   EOS
+      #
+      #   do_something(<<EOS)
+      #   EOS
+      #
+      #   # good
+      #   do_something('')
+      #
+      class EmptyHeredoc < Base
+        include Heredoc
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use an empty string literal instead of heredoc.'
+
+        def on_heredoc(node)
+          heredoc_body = node.loc.heredoc_body
+
+          return unless heredoc_body.source.empty?
+
+          add_offense(node) do |corrector|
+            heredoc_end = node.loc.heredoc_end
+
+            corrector.replace(node, preferred_string_literal)
+            corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
+            corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           return unless send_node.send_type?
 
@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -52,7 +52,7 @@ module RuboCop
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
-          return if node.body || comment_lines?(node)
+          return if node.body || processed_source.contains_comment?(node.source_range)
           return if correct_style?(node)
 
           add_offense(node) do |corrector|

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

@@ -39,7 +39,7 @@ module RuboCop
       #
       # @example EnforcedStyle: disallow
       #   # bad
-      #   def my_method; x end
+      #   def my_method() = x
       #
       #   # bad
       #   def my_method() = x.foo

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

@@ -146,7 +146,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.loc.expression, message: message) do |corrector|
+          add_offense(line_node.source_range, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
@@ -175,14 +175,14 @@ module RuboCop
         end
 
         def line_difference(line_node, code)
-          string_first_line(code) - line_node.loc.expression.first_line
+          string_first_line(code) - line_node.source_range.first_line
         end
 
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
           else
-            str_node.loc.expression.first_line
+            str_node.source_range.first_line
           end
         end
 
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+            corrector.insert_after(node.last_argument.source_range.end, ", #{line_str}")
           end
         end
 

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for exact regexp match inside Regexp literals.
+      #
+      # @example
+      #
+      #   # bad
+      #   string =~ /\Astring\z/
+      #   string === /\Astring\z/
+      #   string.match(/\Astring\z/)
+      #   string.match?(/\Astring\z/)
+      #
+      #   # good
+      #   string == 'string'
+      #
+      #   # bad
+      #   string !~ /\Astring\z/
+      #
+      #   # good
+      #   string != 'string'
+      #
+      class ExactRegexpMatch < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[=~ === !~ match match?].freeze
+
+        # @!method exact_regexp_match(node)
+        def_node_matcher :exact_regexp_match, <<~PATTERN
+          (send
+            _ {:=~ :=== :!~ :match :match?}
+            (regexp
+              (str $_)
+              (regopt)))
+        PATTERN
+
+        def on_send(node)
+          return unless (regexp = exact_regexp_match(node))
+
+          parsed_regexp = Regexp::Parser.parse(regexp)
+          tokens = parsed_regexp.map(&:token)
+          return unless tokens[0] == :bos && tokens[1] == :literal && tokens[2] == :eos
+
+          prefer = "#{node.receiver.source} #{new_method(node)} '#{parsed_regexp[1].text}'"
+
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+
+        private
+
+        def new_method(node)
+          node.method?(:!~) ? '!=' : '=='
+        end
+      end
+    end
+  end
+end

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

@@ -50,6 +50,10 @@ module RuboCop
           (block $_ (args $...) (yield $...))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
+
         def initialize(config = nil, options = nil)
           super
           @def_nodes = Set.new
@@ -141,7 +145,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -9,32 +9,15 @@ module RuboCop
       # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
       # specified default value.
       #
-      # When an `ENV[]` is the LHS of `||`, the autocorrect makes the RHS
-      # the default value of `ENV.fetch`.
-      #
       # @example
       #   # bad
       #   ENV['X']
-      #   ENV['X'] || 'string literal'
-      #   ENV['X'] || some_method
       #   x = ENV['X']
       #
-      #   ENV['X'] || y.map do |a|
-      #     puts a * 2
-      #   end
-      #
       #   # good
       #   ENV.fetch('X')
-      #   ENV.fetch('X', 'string literal')
-      #   ENV.fetch('X') { some_method }
       #   x = ENV.fetch('X')
       #
-      #   ENV.fetch('X') do
-      #     y.map do |a|
-      #       puts a * 2
-      #     end
-      #   end
-      #
       #   # also good
       #   !ENV['X']
       #   ENV['X'].some_method # (e.g. `.nil?`)
@@ -42,48 +25,20 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        # rubocop:disable Layout/LineLength
-        MSG_DEFAULT_NIL = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
-        MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH = 'Use `ENV.fetch(%<key>s, %<default>s)` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK = 'Use `ENV.fetch(%<key>s) { %<default>s }` instead of `ENV[%<key>s] || %<default>s`.'
-        MSG_DEFAULT_RHS_MULTILINE_BLOCK = 'Use `ENV.fetch(%<key>s)` with a block containing `%<default>s ...`'
-        # rubocop:enable Layout/LineLength
+        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN
           (send (const nil? :ENV) :[] $_)
         PATTERN
 
-        # @!method operand_of_or?(node)
-        def_node_matcher :operand_of_or?, <<~PATTERN
-          (^or ...)
-        PATTERN
-
-        # @!method block_control?(node)
-        def_node_matcher :block_control?, <<~PATTERN
-          ({next | break | retry | redo})
-        PATTERN
-
-        # @!method offensive_nodes(node)
-        def_node_search :offensive_nodes, <<~PATTERN
-          [#env_with_bracket? #offensive?]
-        PATTERN
-
         def on_send(node)
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            if operand_of_or?(node)
-              target_node = offensive_nodes(or_chain_root(node)).to_a.last
-              target_name_node = env_with_bracket?(target_node)
-
-              if default_to_rhs?(target_node)
-                default_rhs(target_node, target_name_node)
-              else
-                default_nil(target_node, target_name_node)
-              end
-            else
-              default_nil(node, name_node)
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
             end
           end
         end
@@ -130,17 +85,6 @@ module RuboCop
           !(allowed_var?(node) || allowable_use?(node))
         end
 
-        def or_chain_root(node)
-          while operand_of_or?(ancestor_or ||= node.parent)
-            ancestor_or = ancestor_or.parent
-          end
-          ancestor_or
-        end
-
-        def default_to_rhs?(node)
-          operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
-        end
-
         # Check if the node is a receiver and receives a message with dot syntax.
         def message_chained_with_dot?(node)
           return false if node.root?
@@ -157,8 +101,9 @@ module RuboCop
         #   it simply checks whether the variable is set.
         # - Receiving a message with dot syntax, e.g. `ENV['X'].nil?`.
         # - `ENV['key']` assigned by logical AND/OR assignment.
+        # - `ENV['key']` is the LHS of a `||`.
         def allowable_use?(node)
-          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node)
+          used_as_flag?(node) || message_chained_with_dot?(node) || assigned?(node) || or_lhs?(node)
         end
 
         # The following are allowed cases:
@@ -172,127 +117,15 @@ module RuboCop
           node == lhs
         end
 
-        def left_end_of_or_chains?(node)
-          return false unless operand_of_or?(node)
-
-          node.parent.lhs == node
-        end
-
-        def right_end_of_or_chains?(node)
-          !(left_end_of_or_chains?(node) || node.parent&.parent&.or_type?)
-        end
-
-        def conterpart_rhs_of(node)
-          left_end_of_or_chains?(node) ? node.parent.rhs : node.parent.parent.rhs
-        end
-
-        def rhs_can_be_default_value?(node)
-          !rhs_is_block_control?(node)
-        end
+        def or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
 
-        def rhs_is_block_control?(node)
-          block_control?(conterpart_rhs_of(node))
+          parent.lhs == node || parent.parent&.or_type?
         end
 
-        def new_code_default_nil(name_node)
+        def new_code(name_node)
           "ENV.fetch(#{name_node.source}, nil)"
         end
-
-        def new_code_default_rhs_single_line(node, name_node)
-          parent = node.parent
-          if parent.rhs.basic_literal?
-            "ENV.fetch(#{name_node.source}, #{parent.rhs.source})"
-          else
-            "ENV.fetch(#{name_node.source}) { #{parent.rhs.source} }"
-          end
-        end
-
-        def new_code_default_rhs_multiline(node, name_node)
-          env_indent = indent(node.parent)
-          default = node.parent.rhs.source.split("\n").map do |line|
-            "#{env_indent}#{line}"
-          end.join("\n")
-          <<~NEW_CODE.chomp
-            ENV.fetch(#{name_node.source}) do
-            #{configured_indentation}#{default}
-            #{env_indent}end
-          NEW_CODE
-        end
-
-        def new_code_default_rhs(node, name_node)
-          if node.parent.rhs.single_line?
-            new_code_default_rhs_single_line(node, name_node)
-          else
-            new_code_default_rhs_multiline(node, name_node)
-          end
-        end
-
-        def default_rhs(node, name_node)
-          if left_end_of_or_chains?(node)
-            default_rhs_in_same_or(node, name_node)
-          else
-            default_rhs_in_outer_or(node, name_node)
-          end
-        end
-
-        # Adds an offense and sets `nil` to the default value of `ENV.fetch`.
-        # `ENV['X']` --> `ENV.fetch('X', nil)`
-        def default_nil(node, name_node)
-          message = format(MSG_DEFAULT_NIL, key: name_node.source)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, new_code_default_nil(name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `ENV['X'] || y` --> `ENV.fetch('X') { y }`
-        def default_rhs_in_same_or(node, name_node)
-          template = message_template_for(node.parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(node.parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node.parent, new_code_default_rhs(node, name_node))
-          end
-        end
-
-        # Adds an offense and makes the RHS the default value of `ENV.fetch`.
-        # `z || ENV['X'] || y` --> `z || ENV.fetch('X') { y }`
-        def default_rhs_in_outer_or(node, name_node)
-          parent = node.parent
-          grand_parent = parent.parent
-
-          template = message_template_for(grand_parent.rhs)
-          message = format(template,
-                           key: name_node.source,
-                           default: first_line_of(grand_parent.rhs.source))
-
-          add_offense(node, message: message) do |corrector|
-            lhs_code = parent.lhs.source
-            rhs_code = new_code_default_rhs(parent, name_node)
-            corrector.replace(grand_parent, "#{lhs_code} || #{rhs_code}")
-          end
-        end
-
-        def message_template_for(rhs)
-          if rhs.multiline?
-            MSG_DEFAULT_RHS_MULTILINE_BLOCK
-          elsif rhs.basic_literal?
-            MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH
-          else
-            MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK
-          end
-        end
-
-        def configured_indentation
-          ' ' * (config.for_cop('Layout/IndentationWidth')['Width'] || 2)
-        end
-
-        def first_line_of(source)
-          source.split("\n").first
-        end
       end
     end
   end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer to use `File.empty?('path/to/file')` when checking if a file is empty.
+      #
+      # @safety
+      #   This cop is unsafe, because `File.size`, `File.read`, and `File.binread`
+      #   raise `ENOENT` exception when there is no file corresponding to the path,
+      #   while `File.empty?` does not raise an exception.
+      #
+      # @example
+      #   # bad
+      #   File.zero?('path/to/file')
+      #   File.size('path/to/file') == 0
+      #   File.size('path/to/file') >= 0
+      #   File.size('path/to/file').zero?
+      #   File.read('path/to/file').empty?
+      #   File.binread('path/to/file') == ''
+      #   FileTest.zero?('path/to/file')
+      #
+      #   # good
+      #   File.empty?('path/to/file')
+      #   FileTest.empty?('path/to/file')
+      #
+      class FileEmpty < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<file_class>s.empty?(%<arg>s)` instead.'
+        RESTRICT_ON_SEND = %i[>= != == zero? empty?].freeze
+
+        minimum_target_ruby_version 2.4
+
+        # @!method offensive?(node)
+        def_node_matcher :offensive?, <<~PATTERN
+          {
+            (send $(const {nil? cbase} {:File :FileTest}) :zero? $_)
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) {:== :>=} (int 0))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :!) {:== :>=} (int 0))
+            (send (send $(const {nil? cbase} {:File :FileTest}) :size $_) :zero?)
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) {:!= :==} (str empty?))
+            (send (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :!) {:!= :==} (str empty?))
+            (send (send $(const {nil? cbase} {:File :FileTest}) {:read :binread} $_) :empty?)
+          }
+        PATTERN
+
+        def on_send(node)
+          offensive?(node) do |const_node, arg_node|
+            add_offense(node,
+                        message: format(MSG, file_class: const_node.source,
+                                             arg: arg_node.source)) do |corrector|
+              corrector.replace(node,
+                                "#{bang(node)}#{const_node.source}.empty?(#{arg_node.source})")
+            end
+          end
+        end
+
+        private
+
+        def bang(node)
+          if (node.method?(:==) && node.child_nodes.first.method?(:!)) ||
+             (%i[>= !=].include?(node.method_name) && !node.child_nodes.first.method?(:!))
+            '!'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -71,7 +71,7 @@ module RuboCop
             message = format(MSG, read_method: read_method(mode))
 
             add_offense(read_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, read_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, read_node.source_range.end_pos)
               replacement = "#{read_method(mode)}(#{filename.source})"
 
               corrector.replace(range, replacement)

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

@@ -74,7 +74,7 @@ module RuboCop
             message = format(MSG, write_method: write_method(mode))
 
             add_offense(write_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, write_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, write_node.source_range.end_pos)
               replacement = replacement(mode, filename, content, write_node)
 
               corrector.replace(range, replacement)

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

@@ -75,6 +75,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def suspect_enumerable?(node)

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

@@ -11,7 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
-      # This cop can be customized ignored methods with `IgnoredMethods`.
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -61,18 +62,34 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
-      # @example IgnoredMethods: [redirect]
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: ['redirect']
       #
       #   # good
       #   redirect('foo/%{bar_id}')
       #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         def on_str(node)
-          return if format_string_token?(node) || use_ignored_method?(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -97,9 +114,11 @@ module RuboCop
           !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
         end
 
-        def use_ignored_method?(node)
+        def use_allowed_method?(node)
           send_parent = node.each_ancestor(:send).first
-          send_parent && ignored_method?(send_parent.method_name)
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(send_parent.method_name))
         end
 
         def check_sequence(detected_sequence, token_range)

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def frozen_string_literal_comment(processed_source)
-          processed_source.find_token do |token|
+          processed_source.tokens.find do |token|
             token.text.start_with?(FROZEN_STRING_LITERAL)
           end
         end