rubocop 0.51.0 → 0.87.0

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

@@ -3,19 +3,52 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of the *for* keyword, or *each* method. The
+      # This cop 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, however.
+      # parameter. An `each` call with a block on a single line is always
+      # allowed.
+      #
+      # @example EnforcedStyle: each (default)
+      #   # bad
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: for
+      #   # bad
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
       class For < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
+
         EACH_LENGTH = 'each'.length
+        PREFER_EACH = 'Prefer `each` over `for`.'
+        PREFER_FOR = 'Prefer `for` over `each`.'
 
         def on_for(node)
           if style == :each
-            msg = 'Prefer `each` over `for`.'
-
-            add_offense(node, location: :keyword, message: msg) do
+            add_offense(node, message: PREFER_EACH) do
               opposite_style_detected
             end
           else
@@ -24,28 +57,30 @@ module RuboCop
         end
 
         def on_block(node)
-          return if node.single_line?
-
-          return unless node.send_node.method?(:each) &&
-                        !node.send_node.arguments?
+          return unless suspect_enumerable?(node)
 
           if style == :for
-            incorrect_style_detected(node.send_node)
+            add_offense(node, message: PREFER_FOR) do
+              opposite_style_detected
+            end
           else
             correct_style_detected
           end
         end
 
-        private
+        def autocorrect(node)
+          if style == :each
+            ForToEachCorrector.new(node)
+          else
+            EachToForCorrector.new(node)
+          end
+        end
 
-        def incorrect_style_detected(method)
-          end_pos = method.source_range.end_pos
-          range = range_between(end_pos - EACH_LENGTH, end_pos)
-          msg = 'Prefer `for` over `each`.'
+        private
 
-          add_offense(range, location: range, message: msg) do
-            opposite_style_detected
-          end
+        def suspect_enumerable?(node)
+          node.multiline? &&
+            node.send_node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -10,17 +10,46 @@ module RuboCop
       # manner for all cases, so only two scenarios are considered -
       # if the first argument is a string literal and if the second
       # argument is an array literal.
+      #
+      # @example EnforcedStyle: format (default)
+      #   # bad
+      #   puts sprintf('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts format('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts sprintf('%10s', 'hoge')
+      #
+      #   # good
+      #   puts '%10s' % 'hoge'
+      #
       class FormatString < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Favor `%s` over `%s`.'.freeze
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'
+
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
+        PATTERN
 
-        def_node_matcher :formatter, <<-PATTERN
-        {
-          (send nil? ${:sprintf :format} _ _ ...)
-          (send {str dstr} $:% ... )
-          (send !nil? $:% {array hash})
-        }
+        def_node_matcher :variable_argument?, <<~PATTERN
+          (send {str dstr} :% {send_type? lvar_type?})
         PATTERN
 
         def on_send(node)
@@ -35,7 +64,9 @@ module RuboCop
         end
 
         def message(detected_style)
-          format(MSG, method_name(style), method_name(detected_style))
+          format(MSG,
+                 prefer: method_name(style),
+                 current: method_name(detected_style))
         end
 
         def method_name(style_name)
@@ -43,10 +74,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            _receiver, detected_method = *node
+          return if variable_argument?(node)
 
-            case detected_method
+          lambda do |corrector|
+            case node.method_name
             when :%
               autocorrect_from_percent(corrector, node)
             when :format, :sprintf
@@ -63,32 +94,32 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          receiver, _method, args = *node
-          format = receiver.source
-          args = if args.array_type? || args.hash_type?
-                   args.children.map(&:source).join(', ')
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
                  else
-                   args.source
+                   percent_rhs.source
                  end
-          corrected = "#{style}(#{format}, #{args})"
-          corrector.replace(node.loc.expression, corrected)
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
+          corrector.replace(node, corrected)
         end
 
         def autocorrect_to_percent(corrector, node)
-          _nil, _method, format, *args = *node
-          format = format.source
-          args   = if args.one?
-                     arg = args.first
-                     if arg.hash_type?
-                       "{ #{arg.source} }"
-                     else
-                       arg.source
-                     end
-                   else
-                     "[#{args.map(&:source).join(', ')}]"
-                   end
-          corrected = "#{format} % #{args}"
-          corrector.replace(node.loc.expression, corrected)
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
+
+          args = if param_args.one?
+                   arg = param_args.last
+
+                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                 else
+                   "[#{param_args.map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node, "#{format} % #{args}")
         end
       end
     end

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

@@ -5,48 +5,47 @@ module RuboCop
     module Style
       # Use a consistent style for named format string tokens.
       #
-      # @example
+      # NOTE: `unannotated` style cop only works for strings
+      # which are passed as arguments to those methods:
+      # `printf`, `sprintf`, `format`, `%`.
+      # The reason is that _unannotated_ format is very similar
+      # to encoded URLs or Date/Time formatting strings.
       #
-      #   EnforcedStyle: annotated
+      # @example EnforcedStyle: annotated (default)
       #
       #   # bad
-      #
       #   format('%{greeting}', greeting: 'Hello')
       #   format('%s', 'Hello')
       #
       #   # good
-      #
       #   format('%<greeting>s', greeting: 'Hello')
       #
-      # @example
-      #
-      #   EnforcedStyle: template
+      # @example EnforcedStyle: template
       #
       #   # bad
-      #
       #   format('%<greeting>s', greeting: 'Hello')
       #   format('%s', 'Hello')
       #
       #   # good
-      #
       #   format('%{greeting}', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: unannotated
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%{greeting}', 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
       class FormatStringToken < Cop
         include ConfigurableEnforcedStyle
 
-        FIELD_CHARACTERS = Regexp.union(%w[A B E G X a b c d e f g i o p s u x])
-
-        STYLE_PATTERNS = {
-          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
-          template:  /(?<token>%\{[^\}]+\})/
-        }.freeze
-
-        TOKEN_PATTERN = Regexp.union(STYLE_PATTERNS.values)
-
         def on_str(node)
-          return if node.each_ancestor(:xstr).any?
+          return if node.each_ancestor(:xstr, :regexp).any?
 
           tokens(node) do |detected_style, token_range|
-            if detected_style == style
+            if detected_style == style ||
+               unannotated_format?(node, detected_style)
               correct_style_detected
             else
               style_detected(detected_style)
@@ -58,18 +57,31 @@ module RuboCop
 
         private
 
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
+
+        def unannotated_format?(node, detected_style)
+          detected_style == :unannotated &&
+            !format_string_in_typical_context?(node)
+        end
+
         def message(detected_style)
           "Prefer #{message_text(style)} over #{message_text(detected_style)}."
         end
 
-        # rubocop:disable FormatStringToken
+        # rubocop:disable Style/FormatStringToken
         def message_text(style)
           case style
           when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template  then 'template tokens (like `%{foo}`)'
+          when :template then 'template tokens (like `%{foo}`)'
+          when :unannotated then 'unannotated tokens (like `%s`)'
           end
         end
-        # rubocop:enable FormatStringToken
+        # rubocop:enable Style/FormatStringToken
 
         def tokens(str_node, &block)
           return if str_node.source == '__FILE__'
@@ -81,60 +93,26 @@ module RuboCop
           if source_map.is_a?(Parser::Source::Map::Heredoc)
             source_map.heredoc_body
           elsif source_map.begin
-            slice_source(
-              source_map.expression,
-              source_map.expression.begin_pos + 1,
-              source_map.expression.end_pos - 1
-            )
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
           else
             source_map.expression
           end
         end
 
         def token_ranges(contents)
-          while (offending_match = match_token(contents))
-            detected_style, *range = *offending_match
-            token, contents = split_token(contents, *range)
-            yield(detected_style, token)
-          end
-        end
-
-        def match_token(source_range)
-          supported_styles.each do |style_name|
-            pattern = STYLE_PATTERNS.fetch(style_name)
-            match = source_range.source.match(pattern)
-            next unless match
-
-            return [style_name, match.begin(:token), match.end(:token)]
-          end
-
-          nil
-        end
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-        def split_token(source_range, match_begin, match_end)
-          token =
-            slice_source(
-              source_range,
-              source_range.begin_pos + match_begin,
-              source_range.begin_pos + match_end
-            )
+          format_string.format_sequences.each do |seq|
+            next if seq.percent?
 
-          remainder =
-            slice_source(
-              source_range,
-              source_range.begin_pos + match_end,
-              source_range.end_pos
+            detected_style = seq.style
+            token = contents.begin.adjust(
+              begin_pos: seq.begin_pos,
+              end_pos:   seq.end_pos
             )
 
-          [token, remainder]
-        end
-
-        def slice_source(source_range, new_begin, new_end)
-          Parser::Source::Range.new(
-            source_range.source_buffer,
-            new_begin,
-            new_end
-          )
+            yield(detected_style, token)
+          end
         end
       end
     end

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

@@ -3,55 +3,141 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help upgrade to Ruby 3.0. It will add the
-      # comment `# frozen_string_literal: true` to the top of files to
-      # enable frozen string literals. Frozen string literals will be default
-      # in Ruby 3.0. The comment will be added below a shebang and encoding
-      # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      # This cop is designed to help you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the comment `# frozen_string_literal: true` 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.
+      #
+      # Note that the cop will ignore files where the comment exists but is set
+      # to `false` instead of `true`.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # The `always` style will always add the frozen string literal comment
+      #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+      #   # called on a string literal.
+      #   # bad
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: never
+      #   # The `never` will enforce that the frozen string literal comment does
+      #   # not exist in a file.
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: always_true
+      #   # The `always_true` style enforces that the frozen string literal
+      #   # comment is set to `true`. This is a stricter option than `always`
+      #   # and forces projects to use frozen string literals.
+      #   # bad
+      #   # frozen_string_literal: false
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
       class FrozenStringLiteralComment < Cop
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
+        include RangeHelp
 
-        MSG = 'Missing magic comment `# frozen_string_literal: true`.'.freeze
-        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'.freeze
-        SHEBANG = '#!'.freeze
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
+                           'true`.'
+        MSG_MISSING = 'Missing frozen string literal comment.'
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
+        MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
+        SHEBANG = '#!'
 
         def investigate(processed_source)
-          return if style == :when_needed && target_ruby_version < 2.3
           return if processed_source.tokens.empty?
 
-          if frozen_string_literal_comment_exists?
-            check_for_no_comment(processed_source)
+          case style
+          when :never
+            ensure_no_comment(processed_source)
+          when :always_true
+            ensure_enabled_comment(processed_source)
           else
-            check_for_comment(processed_source)
+            ensure_comment(processed_source)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :never
-              corrector.remove(range_with_surrounding_space(node.pos, :right))
-            else
-              last_special_comment = last_special_comment(processed_source)
-              if last_special_comment.nil?
-                corrector.insert_before(processed_source.tokens[0].pos,
-                                        "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+            case style
+            when :never
+              remove_comment(corrector, node)
+            when :always_true
+              if frozen_string_literal_specified?
+                enable_comment(corrector)
               else
-                corrector.insert_after(last_special_comment.pos,
-                                       "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+                insert_comment(corrector)
               end
+            else
+              insert_comment(corrector)
             end
           end
         end
 
         private
 
-        def check_for_no_comment(processed_source)
-          unnecessary_comment_offense(processed_source) if style == :never
+        def ensure_no_comment(processed_source)
+          return unless frozen_string_literal_comment_exists?
+
+          unnecessary_comment_offense(processed_source)
+        end
+
+        def ensure_comment(processed_source)
+          return if frozen_string_literal_comment_exists?
+
+          missing_offense(processed_source)
         end
 
-        def check_for_comment(processed_source)
-          offense(processed_source) unless style == :never
+        def ensure_enabled_comment(processed_source)
+          if frozen_string_literal_specified?
+            return if frozen_string_literals_enabled?
+
+            # The comment exists, but is not enabled.
+            disabled_offense(processed_source)
+          else # The comment doesn't exist at all.
+            missing_true_offense(processed_source)
+          end
         end
 
         def last_special_comment(processed_source)
@@ -61,25 +147,34 @@ module RuboCop
             token_number += 1
           end
 
-          if processed_source.tokens[token_number].text =~
-             Encoding::ENCODING_PATTERN
-            token = processed_source.tokens[token_number]
-          end
+          next_token = processed_source.tokens[token_number]
+          token = next_token if Encoding::ENCODING_PATTERN.match?(next_token&.text)
 
           token
         end
 
         def frozen_string_literal_comment(processed_source)
-          processed_source.tokens.find do |token|
+          processed_source.find_token do |token|
             token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
           end
         end
 
-        def offense(processed_source)
+        def missing_offense(processed_source)
           last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment, location: range)
+          add_offense(last_special_comment,
+                      location: range,
+                      message: MSG_MISSING)
+        end
+
+        def missing_true_offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment,
+                      location: range,
+                      message: MSG_MISSING_TRUE)
         end
 
         def unnecessary_comment_offense(processed_source)
@@ -90,6 +185,49 @@ module RuboCop
                       location: frozen_string_literal_comment.pos,
                       message: MSG_UNNECESSARY)
         end
+
+        def disabled_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      location: frozen_string_literal_comment.pos,
+                      message: MSG_DISABLED)
+        end
+
+        def remove_comment(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.pos,
+                                                        side: :right))
+        end
+
+        def enable_comment(corrector)
+          comment = frozen_string_literal_comment(processed_source)
+
+          corrector.replace(line_range(comment.line),
+                            FROZEN_STRING_LITERAL_ENABLED)
+        end
+
+        def insert_comment(corrector)
+          comment = last_special_comment(processed_source)
+
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
+          else
+            corrector.insert_before(processed_source.buffer.source_range, preceding_comment)
+          end
+        end
+
+        def line_range(line)
+          processed_source.buffer.line_range(line)
+        end
+
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
+
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
+        end
       end
     end
   end