rubocop 0.70.0 → 0.75.0

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

@@ -45,15 +45,15 @@ module RuboCop
         CLASS_MSG = 'Prefer Time over DateTime.'
         COERCION_MSG = 'Do not use #to_datetime.'
 
-        def_node_matcher :date_time?, <<-PATTERN
+        def_node_matcher :date_time?, <<~PATTERN
           (send (const {nil? (cbase)} :DateTime) ...)
         PATTERN
 
-        def_node_matcher :historic_date?, <<-PATTERN
+        def_node_matcher :historic_date?, <<~PATTERN
           (send _ _ _ (const (const nil? :Date) _))
         PATTERN
 
-        def_node_matcher :to_datetime?, <<-PATTERN
+        def_node_matcher :to_datetime?, <<~PATTERN
           (send _ :to_datetime)
         PATTERN
 

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

@@ -20,7 +20,7 @@ module RuboCop
         MSG = 'Use `__dir__` to get an absolute path to the current ' \
               "file's directory."
 
-        def_node_matcher :dir_replacement?, <<-PATTERN
+        def_node_matcher :dir_replacement?, <<~PATTERN
           {(send (const nil? :File) :expand_path (send (const nil? :File) :dirname  #file_keyword?))
            (send (const nil? :File) :dirname     (send (const nil? :File) :realpath #file_keyword?))}
         PATTERN

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

@@ -53,7 +53,7 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
-        def_node_matcher :module_function_node?, <<-PATTERN
+        def_node_matcher :module_function_node?, <<~PATTERN
           (send nil? :module_function ...)
         PATTERN
 

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+
+module RuboCop
+  module Cop
+    module Style
+      # Detects double disable comments on one line. This is mostly to catch
+      # automatically generated comments that need to be regenerated.
+      #
+      # @example
+      #   # bad
+      #   def f # rubocop:disable Style/For # rubocop:disable Metrics/AbcSize
+      #   end
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def f # rubocop:disable Style/For
+      #   end
+      #   # rubocop:enable Metrics/AbcSize
+      #
+      #   # if both fit on one line
+      #   def f # rubocop:disable Style/For, Metrics/AbcSize
+      #   end
+      #
+      class DoubleCopDisableDirective < Cop
+        # rubocop:enable Style/For, Style/DoubleCopDisableDirective
+        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        MSG = 'More than one disable comment on one line.'
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            next unless comment.text.scan(/# rubocop:(?:disable|todo)/).size > 1
+
+            add_offense(comment)
+          end
+        end
+
+        def autocorrect(comment)
+          prefix = if comment.text.start_with?('# rubocop:disable')
+                     '# rubocop:disable'
+                   else
+                     '# rubocop:todo'
+                   end
+
+          lambda do |corrector|
+            corrector.replace(comment.loc.expression,
+                              comment.text[/#{prefix} \S+/])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        def_node_matcher :offending_each_range, <<-PATTERN
+        def_node_matcher :offending_each_range, <<~PATTERN
           (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN
       end

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        def_node_matcher :each_with_object_candidate?, <<-PATTERN
+        def_node_matcher :each_with_object_candidate?, <<~PATTERN
           (block $(send _ {:inject :reduce} _) $_ $_)
         PATTERN
 

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

@@ -37,7 +37,7 @@ module RuboCop
         MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
                              'as they are used by backtraces.'
 
-        def_node_matcher :eval_without_location?, <<-PATTERN
+        def_node_matcher :eval_without_location?, <<~PATTERN
           {
             (send nil? :eval ${str dstr})
             (send nil? :eval ${str dstr} _)
@@ -53,7 +53,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :line_with_offset?, <<-PATTERN
+        def_node_matcher :line_with_offset?, <<~PATTERN
           {
             (send #special_line_keyword? %1 (int %2))
             (send (int %2) %1 #special_line_keyword?)

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

@@ -18,7 +18,7 @@ module RuboCop
       class EvenOdd < Cop
         MSG = 'Replace with `Integer#%<method>s?`.'
 
-        def_node_matcher :even_odd_candidate?, <<-PATTERN
+        def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}

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

@@ -51,21 +51,21 @@ module RuboCop
                            'instead of ' \
                            '`Pathname.new(__FILE__).parent.expand_path`.'
 
-        def_node_matcher :file_expand_path, <<-PATTERN
+        def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const nil? :File) :expand_path
             $_
             $_)
         PATTERN
 
-        def_node_matcher :pathname_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
               (send nil? :Pathname
                 $_) :parent) :expand_path)
         PATTERN
 
-        def_node_matcher :pathname_new_parent_expand_path, <<-PATTERN
+        def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send
               (send

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop 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.
+      #
+      # @example EnforcedStyle: single_coerce (default)
+      #   # bad
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: left_coerce
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #
+      # @example EnforcedStyle: right_coerce
+      #   # bad
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: fdiv
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.fdiv(b)
+      class FloatDivision < Cop
+        include ConfigurableEnforcedStyle
+
+        def_node_matcher :right_coerce?, <<~PATTERN
+          (send _ :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :left_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ _)
+        PATTERN
+        def_node_matcher :both_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :any_coerce?, <<~PATTERN
+          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if offense_condition?(node)
+        end
+
+        private
+
+        def offense_condition?(node)
+          case style
+          when :left_coerce
+            right_coerce?(node)
+          when :right_coerce
+            left_coerce?(node)
+          when :single_coerce
+            both_coerce?(node)
+          when :fdiv
+            any_coerce?(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          case style
+          when :left_coerce
+            'Prefer using `.to_f` on the left side.'
+          when :right_coerce
+            'Prefer using `.to_f` on the right side.'
+          when :single_coerce
+            'Prefer using `.to_f` on one side only.'
+          when :fdiv
+            'Prefer using `fdiv` for float divisions.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,12 +40,16 @@ module RuboCop
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
 
-        def_node_matcher :formatter, <<-PATTERN
-        {
-          (send nil? ${:sprintf :format} _ _ ...)
-          (send {str dstr} $:% ... )
-          (send !nil? $:% {array hash})
-        }
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
+        PATTERN
+
+        def_node_matcher :variable_argument?, <<~PATTERN
+          (send {str dstr} :% {send_type? lvar_type?})
         PATTERN
 
         def on_send(node)
@@ -70,10 +74,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            detected_method = node.method_name
+          return if variable_argument?(node)
 
-            case detected_method
+          lambda do |corrector|
+            case node.method_name
             when :%
               autocorrect_from_percent(corrector, node)
             when :format, :sprintf

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

@@ -41,15 +41,8 @@ module RuboCop
       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])
         FORMAT_STRING_METHODS = %i[sprintf format %].freeze
 
-        STYLE_PATTERNS = {
-          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
-          template: /(?<token>%\{[^\}]+\})/,
-          unannotated: /(?<token>%#{FIELD_CHARACTERS})/
-        }.freeze
-
         def on_str(node)
           return if placeholder_argument?(node)
           return if node.each_ancestor(:xstr, :regexp).any?
@@ -113,41 +106,18 @@ module RuboCop
         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
-
-        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
-            )
-
-          remainder =
-            slice_source(
-              source_range,
-              source_range.begin_pos + match_end,
-              source_range.end_pos
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
+
+          format_string.format_sequences.each do |seq|
+            detected_style = seq.style
+            token = slice_source(
+              contents,
+              contents.begin_pos + seq.begin_pos,
+              contents.begin_pos + seq.end_pos
             )
 
-          [token, remainder]
+            yield(detected_style, token)
+          end
         end
 
         def slice_source(source_range, new_begin, new_end)

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

@@ -3,11 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help upgrade to after 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 may be default
-      # after 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. The frozen string literal comment is only valid in
+      # Ruby 2.3+.
       #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
@@ -121,42 +123,25 @@ module RuboCop
         end
 
         def insert_comment(corrector)
-          last_special_comment = last_special_comment(processed_source)
-          if last_special_comment.nil?
-            corrector.insert_before(correction_range, preceding_comment)
-          else
-            corrector.insert_after(correction_range, proceeding_comment)
-          end
-        end
+          comment = last_special_comment(processed_source)
 
-        def preceding_comment
-          if processed_source.tokens[0].space_before?
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
           else
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n\n"
+            corrector.insert_before(line_range(1), preceding_comment)
           end
         end
 
-        def proceeding_comment
-          last_special_comment = last_special_comment(processed_source)
-          following_line = processed_source.following_line(last_special_comment)
-
-          if following_line&.empty?
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}"
-          else
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}\n"
-          end
+        def line_range(line)
+          processed_source.buffer.line_range(line)
         end
 
-        def correction_range
-          last_special_comment = last_special_comment(processed_source)
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
 
-          if last_special_comment.nil?
-            range_with_surrounding_space(range: processed_source.tokens[0],
-                                         side: :left)
-          else
-            last_special_comment.pos
-          end
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
         end
       end
     end

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

@@ -37,9 +37,10 @@ module RuboCop
       #   ok
       class GuardClause < Cop
         include MinBodyLength
+        include StatementModifier
 
-        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
-              'conditional expression.'
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
 
         def on_def(node)
           body = node.body
@@ -55,9 +56,19 @@ module RuboCop
         alias on_defs on_def
 
         def on_if(node)
-          return if accepted_form?(node) || !contains_guard_clause?(node)
+          return if accepted_form?(node)
 
-          add_offense(node, location: :keyword)
+          guard_clause_in_if = node.if_branch&.guard_clause?
+          guard_clause_in_else = node.else_branch&.guard_clause?
+          guard_clause = guard_clause_in_if || guard_clause_in_else
+          return unless guard_clause
+
+          kw = if guard_clause_in_if
+                 node.loc.keyword.source
+               else
+                 opposite_keyword(node)
+               end
+          register_offense(node, guard_clause.source, kw)
         end
 
         private
@@ -65,7 +76,30 @@ module RuboCop
         def check_ending_if(node)
           return if accepted_form?(node, true) || !min_body_length?(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node, 'return', opposite_keyword(node))
+        end
+
+        def opposite_keyword(node)
+          node.if? ? 'unless' : 'if'
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+          condition, = node.node_parts
+          example = [scope_exiting_keyword,
+                     conditional_keyword,
+                     condition.source].join(' ')
+          if too_long_for_single_line?(node, example)
+            example = "#{conditional_keyword} #{condition.source}; " \
+                      "#{scope_exiting_keyword}; end"
+          end
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, example: example))
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
         end
 
         def accepted_form?(node, ending = false)
@@ -81,11 +115,6 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
-
-        def contains_guard_clause?(node)
-          node.if_branch&.guard_clause? ||
-            node.else_branch&.guard_clause?
-        end
       end
     end
   end