rubocop 1.29.1 → 1.46.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces consistency when using exponential notation
+      # Enforces consistency when using exponential notation
       # for numbers in the code (eg 1.2e4). Different styles are supported:
       #
       # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).

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

@@ -3,38 +3,21 @@
 module RuboCop
   module Cop
     module Style
-      # This cop suggests `ENV.fetch` for the replacement of `ENV[]`.
+      # Suggests `ENV.fetch` for the replacement of `ENV[]`.
       # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
       # which may cause unexpected behaviors when the developer forgets to set it.
       # 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 env_with_bracket_in_descendants?(node)
-        def_node_matcher :env_with_bracket_in_descendants?, <<~PATTERN
-          `(send (const nil? :ENV) :[] $_)
-        PATTERN
-
         def on_send(node)
-          env_with_bracket?(node) do |expression|
+          env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            if operand_of_or?(node)
-              target_node = lookahead_target_node(node)
-              target_expr = env_with_bracket?(target_node)
-
-              if default_to_rhs?(target_node)
-                default_rhs(target_node, target_expr)
-              else
-                default_nil(target_node, target_expr)
-              end
-            else
-              default_nil(node, expression)
+            message = format(MSG, key: name_node.source)
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, new_code(name_node))
             end
           end
         end
@@ -97,19 +52,37 @@ module RuboCop
 
         def used_as_flag?(node)
           return false if node.root?
+          return true if used_if_condition_in_body(node)
 
+          node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
+        end
+
+        def used_if_condition_in_body(node)
           if_node = node.ancestors.find(&:if_type?)
-          return true if if_node&.condition == node
 
-          node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
+          return false unless (condition = if_node&.condition)
+          return true if condition.send_type? && (condition.child_nodes == node.child_nodes)
+
+          used_in_condition?(node, condition)
         end
 
-        def offensive?(node)
-          !(allowed_var?(node) || allowable_use?(node))
+        def used_in_condition?(node, condition)
+          if condition.send_type?
+            return true if condition.assignment_method? && partial_matched?(node, condition)
+            return false if !condition.comparison_method? && !condition.predicate_method?
+          end
+
+          condition.child_nodes.any?(node)
+        end
+
+        # Avoid offending in the following cases:
+        # `ENV['key'] if ENV['key'] = x`
+        def partial_matched?(node, condition)
+          node.child_nodes == node.child_nodes & condition.child_nodes
         end
 
-        def default_to_rhs?(node)
-          operand_of_or?(node) && !right_end_of_or_chains?(node) && rhs_can_be_default_value?(node)
+        def offensive?(node)
+          !(allowed_var?(node) || allowable_use?(node))
         end
 
         # Check if the node is a receiver and receives a message with dot syntax.
@@ -128,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:
@@ -143,175 +117,14 @@ 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
-
-        # Returns the node and expression of the rightmost `ENV[]` in `||` chains.
-        # e.g.,
-        # `ENV['X'] || y || z || ENV['A'] || b`
-        #                        ^^^^^^^^ Matches this one
-        def rightmost_offense_in_or_chains(base_node)
-          or_nodes = [base_node.parent]
-
-          while (grand_parent = or_nodes.last&.parent)&.or_type?
-            or_nodes << grand_parent
-          end
-
-          # Finds the rightmost `ENV[]` in `||` chains.
-          or_node = or_nodes.reverse.find do |n|
-            env_with_bracket?(n.rhs)
-          end
-
-          or_node ? or_node.rhs : base_node
-        end
-
-        def no_env_with_bracket_in_descendants?(node)
-          !env_with_bracket_in_descendants?(node)
-        end
-
-        def conterpart_rhs_of(node)
-          left_end_of_or_chains?(node) ? node.parent.rhs : node.parent.parent.rhs
-        end
-
-        # Looks ahead to the `ENV[]` that must be corrected first, avoiding a cross correction.
-        # ```
-        # ENV['X'] || y.map do |a|
-        #   a.map do |b|
-        #     ENV['Z'] + b
-        #     ^^^^^^^^ This must be corrected first.
-        #   end
-        # end
-        # ```
-        def lookahead_target_node(base_node)
-          return base_node unless operand_of_or?(base_node)
-
-          candidate_node = rightmost_offense_in_or_chains(base_node)
-          return candidate_node if right_end_of_or_chains?(candidate_node)
-
-          counterpart_rhs = conterpart_rhs_of(candidate_node)
-          return candidate_node if no_env_with_bracket_in_descendants?(counterpart_rhs)
-
-          new_base_node = counterpart_rhs.each_descendant.find do |d|
-            env_with_bracket?(d) && offensive?(d)
-          end
-          return candidate_node unless new_base_node
-
-          lookahead_target_node(new_base_node)
-        end
-
-        def rhs_can_be_default_value?(node)
-          !rhs_is_block_control?(node)
-        end
-
-        def rhs_is_block_control?(node)
-          block_control?(conterpart_rhs_of(node))
-        end
-
-        def new_code_default_nil(expression)
-          "ENV.fetch(#{expression.source}, nil)"
-        end
-
-        def new_code_default_rhs_single_line(node, expression)
-          parent = node.parent
-          if parent.rhs.basic_literal?
-            "ENV.fetch(#{expression.source}, #{parent.rhs.source})"
-          else
-            "ENV.fetch(#{expression.source}) { #{parent.rhs.source} }"
-          end
-        end
-
-        def new_code_default_rhs_multiline(node, expression)
-          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(#{expression.source}) do
-            #{configured_indentation}#{default}
-            #{env_indent}end
-          NEW_CODE
-        end
-
-        def new_code_default_rhs(node, expression)
-          if node.parent.rhs.single_line?
-            new_code_default_rhs_single_line(node, expression)
-          else
-            new_code_default_rhs_multiline(node, expression)
-          end
-        end
-
-        def default_rhs(node, expression)
-          if left_end_of_or_chains?(node)
-            default_rhs_in_same_or(node, expression)
-          else
-            default_rhs_in_outer_or(node, expression)
-          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, expression)
-          message = format(MSG_DEFAULT_NIL, key: expression.source)
-
-          add_offense(node, message: message) do |corrector|
-            corrector.replace(node, new_code_default_nil(expression))
-          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, expression)
-          template = message_template_for(node.parent.rhs)
-          message = format(template,
-                           key: expression.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, expression))
-          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, expression)
-          parent = node.parent
-          grand_parent = parent.parent
-
-          template = message_template_for(grand_parent.rhs)
-          message = format(template,
-                           key: expression.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, expression)
-            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 or_lhs?(node)
+          return false unless (parent = node.parent)&.or_type?
 
-        def configured_indentation
-          ' ' * (config.for_cop('Layout/IndentationWidth')['Width'] || 2)
+          parent.lhs == node || parent.parent&.or_type?
         end
 
-        def first_line_of(source)
-          source.split("\n").first
+        def new_code(name_node)
+          "ENV.fetch(#{name_node.source}, nil)"
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for division with integers coerced to floats.
+      # Checks for division with integers coerced to floats.
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of the `for` keyword or `each` method. The
+      # Looks for uses of the `for` keyword or `each` method. The
       # preferred alternative is set in the EnforcedStyle configuration
       # parameter. An `each` call with a block on a single line is always
       # allowed.
@@ -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.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of a single string formatting utility.
+      # Enforces the use of a single string formatting utility.
       # Valid options include Kernel#format, Kernel#sprintf and String#%.
       #
       # The detection of String#% cannot be implemented in a reliable

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,29 +62,41 @@ 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?
           return if allowed_unannotated?(detections)
 
-          detections.each do |detected_style, token_range|
-            if detected_style == style
-              correct_style_detected
-            else
-              style_detected(detected_style)
-              add_offense(token_range, message: message(detected_style))
-            end
+          detections.each do |detected_sequence, token_range|
+            check_sequence(detected_sequence, token_range)
           end
         end
 
@@ -101,9 +114,43 @@ 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)
+          if detected_sequence.style == style
+            correct_style_detected
+          elsif correctable_sequence?(detected_sequence.type)
+            style_detected(detected_sequence.style)
+            add_offense(token_range, message: message(detected_sequence.style)) do |corrector|
+              autocorrect_sequence(corrector, detected_sequence, token_range)
+            end
+          end
+        end
+
+        def correctable_sequence?(detected_type)
+          detected_type == 's' || style == :annotated || style == :unannotated
+        end
+
+        def autocorrect_sequence(corrector, detected_sequence, token_range)
+          return if style == :unannotated
+
+          name = detected_sequence.name
+          return if name.nil?
+
+          flags = detected_sequence.flags
+          width = detected_sequence.width
+          precision = detected_sequence.precision
+          type = detected_sequence.style == :template ? 's' : detected_sequence.type
+          correction = case style
+                       when :annotated then "%<#{name}>#{flags}#{width}#{precision}#{type}"
+                       when :template then "%#{flags}#{width}#{precision}{#{name}}"
+                       end
+          corrector.replace(token_range, correction)
         end
 
         def unannotated_format?(node, detected_style)
@@ -143,30 +190,33 @@ module RuboCop
         def token_ranges(contents)
           format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-          format_string.format_sequences.each do |seq|
-            next if seq.percent?
+          format_string.format_sequences.each do |detected_sequence|
+            next if detected_sequence.percent?
 
-            detected_style = seq.style
-            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
+            token = contents.begin.adjust(begin_pos: detected_sequence.begin_pos,
+                                          end_pos: detected_sequence.end_pos)
 
-            yield(detected_style, token)
+            yield(detected_sequence, token)
           end
         end
 
         def collect_detections(node)
           detections = []
-          tokens(node) do |detected_style, token_range|
-            unless unannotated_format?(node, detected_style)
-              detections << [detected_style, token_range]
+          tokens(node) do |detected_sequence, token_range|
+            unless unannotated_format?(node, detected_sequence.style)
+              detections << [detected_sequence, token_range]
             end
           end
           detections
         end
 
         def allowed_unannotated?(detections)
-          return false if detections.size > max_unannotated_placeholders_allowed
+          return false unless detections.all? do |detected_sequence,|
+                                detected_sequence.style == :unannotated
+                              end
+          return true if detections.size <= max_unannotated_placeholders_allowed
 
-          detections.all? { |detected_style,| detected_style == :unannotated }
+          detections.any? { |detected_sequence,| !correctable_sequence?(detected_sequence.type) }
         end
 
         def max_unannotated_placeholders_allowed

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

@@ -3,12 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help you transition from mutable string literals
+      # Helps you transition from mutable string literals
       # to frozen string literals.
       # It will add the `# frozen_string_literal: true` magic comment to the top
       # of files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
-      # encoding comment.
+      # encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.
       #
       # Note that the cop will accept files where the comment exists but is set
       # to `false` instead of `true`.
@@ -86,6 +86,9 @@ module RuboCop
         include FrozenStringLiteral
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
         MSG_MISSING = 'Missing frozen string literal comment.'
@@ -179,7 +182,7 @@ module RuboCop
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
+          corrector.remove(range_with_surrounding_space(node.pos, side: :right))
         end
 
         def enable_comment(corrector)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
+      # Enforces the use of `$stdout/$stderr/$stdin` instead of `STDOUT/STDERR/STDIN`.
       # `STDOUT/STDERR/STDIN` are constants, and while you can actually
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of global variables.
+      # Looks for uses of global variables.
       # It does not report offenses for built-in global variables.
       # Built-in global variables are allowed by default. Additionally
       # users can allow additional variables via the AllowedVariables option.