rubocop 0.71.0 → 0.75.1

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

@@ -68,16 +68,16 @@ module RuboCop
         private
 
         def expand_elsif(node, elsif_branches = [])
-          return [] if node.nil? || !node.if_type?
+          return [] if node.nil? || !node.if_type? || !node.elsif?
 
           elsif_branches << node.if_branch
 
-          if node.else_branch&.if_type?
-            expand_elsif(node.else_branch, elsif_branches)
+          else_branch = node.else_branch
+          if else_branch&.if_type? && else_branch&.elsif?
+            expand_elsif(else_branch, elsif_branches)
           else
-            elsif_branches << node.else_branch
+            elsif_branches << else_branch
           end
-          elsif_branches
         end
 
         def lhs_for_send(node)
@@ -219,11 +219,9 @@ module RuboCop
         SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
         WIDTH = 'Width'
 
-        def_node_matcher :condition?, '{if case}'
-
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
-        def_node_matcher :assignment_type?, <<-PATTERN
+        def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
             (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
@@ -596,7 +594,8 @@ module RuboCop
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
-            branch_else = branch.parent.loc.else
+            return unless (branch_else = branch.parent.loc.else)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end

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

@@ -46,7 +46,14 @@ module RuboCop
         end
 
         def class_or_module_scope?(node)
-          node.parent && %i[class module].include?(node.parent.type)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
         end
 
         def visibility_declaration?(node)
@@ -57,9 +64,13 @@ module RuboCop
           end
         end
 
-        def_node_matcher :visibility_declaration_for?, <<-PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} %1))
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
         PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
       end
     end
   end

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

@@ -47,13 +47,57 @@ module RuboCop
       #   def foo.bar
       #     puts baz
       #   end
+      #
+      # @example RequireForNonPublicMethods: false (default)
+      #   # good
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      # @example RequireForNonPublicMethods: true
+      #   # bad
+      #   class Foo
+      #     protected
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
+      #   class Foo
+      #     private
+      #     # Documentation
+      #     def do_something
+      #     end
+      #   end
+      #
       class DocumentationMethod < Cop
         include DocumentationComment
         include DefNode
 
         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
@@ -160,7 +160,7 @@ module RuboCop
         def depth(current_path)
           paths = current_path.split(File::SEPARATOR)
 
-          paths.reject { |path| path == '.' }.count
+          paths.count { |path| path != '.' }
         end
 
         def parent_path(current_path)

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

@@ -8,7 +8,7 @@ module RuboCop
       # **Note:**
       # `unannotated` style cop only works for strings
       # which are passed as arguments to those methods:
-      # `sprintf`, `format`, `%`.
+      # `printf`, `sprintf`, `format`, `%`.
       # The reason is that *unannotated* format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
@@ -41,17 +41,7 @@ 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?
 
           tokens(node) do |detected_style, token_range|
@@ -68,14 +58,16 @@ module RuboCop
 
         private
 
-        def includes_format_methods?(node)
-          node.each_ancestor(:send).any? do |ancestor|
-            FORMAT_STRING_METHODS.include?(ancestor.method_name)
-          end
-        end
+        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 && !includes_format_methods?(node)
+          detected_style == :unannotated &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -102,67 +94,24 @@ 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
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-          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.format_sequences.each do |seq|
+            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
-          )
-        end
-
-        def placeholder_argument?(node)
-          return false unless node.parent
-          return true if node.parent.pair_type?
-
-          placeholder_argument?(node.parent)
+            yield(detected_style, token)
+          end
         end
       end
     end