rubocop 0.73.0 → 0.77.0

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,8 +219,6 @@ 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

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)
@@ -58,8 +65,12 @@ module RuboCop
         end
 
         def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} %1))
+          (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/copyright.rb

@@ -33,13 +33,7 @@ module RuboCop
         end
 
         def autocorrect(token)
-          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
-
-          regex = Regexp.new(notice)
-          unless autocorrect_notice =~ regex
-            raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
-                           "match Notice /#{notice}/"
-          end
+          verify_autocorrect_notice!
 
           lambda do |corrector|
             range = token.nil? ? range_between(0, 0) : token.pos
@@ -57,6 +51,16 @@ module RuboCop
           cop_config['AutocorrectNotice']
         end
 
+        def verify_autocorrect_notice!
+          raise Warning, AUTOCORRECT_EMPTY_WARNING if autocorrect_notice.empty?
+
+          regex = Regexp.new(notice)
+          return if autocorrect_notice =~ regex
+
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+                         "match Notice /#{notice}/"
+        end
+
         def insert_notice_before(processed_source)
           token_index = 0
           token_index += 1 if shebang_token?(processed_source, token_index)

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

@@ -47,6 +47,50 @@ 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

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 # rubocop:disable Style/DoubleCopDisableDirective
 
 module RuboCop
@@ -26,21 +26,27 @@ module RuboCop
       #
       class DoubleCopDisableDirective < Cop
         # rubocop:enable Style/For, Style/DoubleCopDisableDirective
-        # rubocop:enable Lint/UnneededCopDisableDirective, Metrics/AbcSize
+        # rubocop:enable Lint/RedundantCopDisableDirective, 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').size > 1
+            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[/# rubocop:disable \S+/])
+                              comment.text[/#{prefix} \S+/])
           end
         end
       end

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

@@ -84,8 +84,8 @@ module RuboCop
 
             next unless conditions.size > 1
 
-            range = range_between(conditions.first.loc.expression.begin_pos,
-                                  conditions.last.loc.expression.end_pos)
+            range = range_between(conditions.first.source_range.begin_pos,
+                                  conditions.last.source_range.end_pos)
 
             corrector.replace(range, conditions.map(&:source).join(' || '))
           end

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

@@ -84,8 +84,8 @@ module RuboCop
             # to rewrite the arguments to wrap them in parenthesis.
             args = node.parent.arguments
 
-            range_between(args[0].loc.expression.begin_pos - 1,
-                          args[-1].loc.expression.end_pos)
+            range_between(args[0].source_range.begin_pos - 1,
+                          args[-1].source_range.end_pos)
           else
             node.source_range
           end

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

@@ -73,11 +73,11 @@ module RuboCop
         end
 
         def corrected(node)
-          has_parentheses = parentheses?(node.arguments)
-
-          arguments   = node.arguments? ? node.arguments.source : ''
-          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
-          scope       = node.receiver ? "#{node.receiver.source}." : ''
+          if node.arguments?
+            arguments   = node.arguments.source
+            extra_space = ' ' unless parentheses?(node.arguments)
+          end
+          scope = node.receiver ? "#{node.receiver.source}." : ''
 
           signature = [scope, node.method_name, extra_space, arguments].join
 

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

@@ -85,7 +85,7 @@ module RuboCop
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
-          if node.method_name == :eval
+          if node.method?(:eval)
             node.arguments.size == 4
           else
             node.arguments.size == 3

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

@@ -23,7 +23,7 @@ module RuboCop
             {(send $_ :% (int 2))
              (begin (send $_ :% (int 2)))}
             ${:== :!=}
-            (int ${0 1 2}))
+            (int ${0 1}))
         PATTERN
 
         def on_send(node)

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

@@ -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/format_string.rb

@@ -94,10 +94,12 @@ module RuboCop
         private
 
         def autocorrect_from_percent(corrector, node)
-          args = if %i[array hash].include?(node.first_argument.type)
-                   node.first_argument.children.map(&:source).join(', ')
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
                  else
-                   node.first_argument.source
+                   percent_rhs.source
                  end
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
@@ -106,14 +108,15 @@ module RuboCop
         end
 
         def autocorrect_to_percent(corrector, node)
-          format = node.first_argument.source
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
 
-          args = if node.arguments.size == 2
-                   arg = node.arguments.last
+          args = if param_args.one?
+                   arg = param_args.last
 
                    arg.hash_type? ? "{ #{arg.source} }" : arg.source
                  else
-                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                   "[#{param_args.map(&:source).join(', ')}]"
                  end
 
           corrector.replace(node.loc.expression, "#{format} % #{args}")

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,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
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
 
-        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
+          format_string.format_sequences.each do |seq|
+            next if seq.percent?
 
-            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
+            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

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

@@ -3,11 +3,16 @@
 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+.
+      #
+      # 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
@@ -25,6 +30,13 @@ module RuboCop
       #     # ...
       #   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.
@@ -121,42 +133,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