rubocop 0.74.0 → 0.75.1

data/lib/rubocop/cop/registry.rb

@@ -91,8 +91,11 @@ module RuboCop
       # @note Emits a warning if the provided name has an incorrect namespace
       #
       # @return [String] Qualified cop name
-      def qualified_cop_name(name, path)
+      def qualified_cop_name(name, path, shall_warn = true)
         badge = Badge.parse(name)
+        if shall_warn && department_missing?(badge, name)
+          print_warning(name, path)
+        end
         return name if registered?(badge)
 
         potential_badges = qualify_badge(badge)
@@ -104,6 +107,24 @@ module RuboCop
         end
       end
 
+      def department_missing?(badge, name)
+        !badge.qualified? && unqualified_cop_names.include?(name)
+      end
+
+      def print_warning(name, path)
+        message = "#{path}: Warning: no department given for #{name}."
+        if path.end_with?('.rb')
+          message += ' Run `rubocop -a --only Migration/DepartmentName` to fix.'
+        end
+        warn message
+      end
+
+      def unqualified_cop_names
+        @unqualified_cop_names ||=
+          Set.new(@cops_by_cop_name.keys.map { |qn| File.basename(qn) }) <<
+          'UnneededCopDisableDirective'
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
         @cops_by_cop_name

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

@@ -63,6 +63,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.access_modifier?
+          return if node.parent.pair_type?
 
           if offense?(node)
             add_offense(node, location: :selector) do

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

@@ -114,7 +114,8 @@ module RuboCop
 
         def on_send(node)
           return unless node.arguments?
-          return if node.parenthesized? || node.operator_method?
+          return if node.parenthesized?
+          return if node.operator_method? || node.assignment_method?
 
           node.arguments.each do |arg|
             get_blocks(arg) do |block|

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

@@ -55,10 +55,6 @@ module RuboCop
         end
         alias on_csend on_send
 
-        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
-        # node, because that context is needed. When parsing the code to see if
-        # the AST has changed, a braceless hash would not be parsed as a hash
-        # otherwise.
         def autocorrect(send_node)
           hash_node = send_node.last_argument
 
@@ -76,20 +72,32 @@ module RuboCop
         private
 
         def check(arg, args)
-          if style == :braces && !arg.braces?
-            add_arg_offense(arg, :missing)
-          elsif style == :no_braces && arg.braces?
-            add_arg_offense(arg, :redundant)
-          elsif style == :context_dependent
+          case style
+          when :braces
+            check_braces(arg)
+          when :no_braces
+            check_no_braces(arg)
+          when :context_dependent
             check_context_dependent(arg, args)
           end
         end
 
+        def check_braces(arg)
+          add_arg_offense(arg, :missing) unless arg.braces?
+        end
+
+        def check_no_braces(arg)
+          return unless arg.braces? && !braces_needed_for_semantics?(arg)
+
+          add_arg_offense(arg, :redundant)
+        end
+
         def check_context_dependent(arg, args)
           braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
 
           if arg.braces?
-            unless braces_around_second_from_end
+            unless braces_around_second_from_end ||
+                   braces_needed_for_semantics?(arg)
               add_arg_offense(arg, :redundant)
             end
           elsif braces_around_second_from_end
@@ -97,6 +105,17 @@ module RuboCop
           end
         end
 
+        # Returns true if there's block inside the braces of the given hash arg
+        # and that block uses do..end. The reason for wanting to check this is
+        # that the do..end could bind to a different method invocation if the
+        # hash braces were removed.
+        def braces_needed_for_semantics?(arg)
+          arg.each_pair do |_key, value|
+            return true if value.block_type? && !value.braces?
+          end
+          false
+        end
+
         def add_arg_offense(arg, type)
           add_offense(arg.parent, location: arg.source_range,
                                   message: format(MSG,

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

@@ -115,7 +115,7 @@ module RuboCop
         end
 
         def indent_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
         end
 
         def check_style(node, body)

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

@@ -6,7 +6,8 @@ module RuboCop
       # This cop checks for comments put on the same line as some keywords.
       # These keywords are: `begin`, `class`, `def`, `end`, `module`.
       #
-      # Note that some comments (`:nodoc:`, `:yields:`, and `rubocop:disable`)
+      # Note that some comments
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
       # are allowed.
       #
       # @example
@@ -45,7 +46,12 @@ module RuboCop
         private
 
         KEYWORDS = %w[begin class def end module].freeze
-        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable].freeze
+        ALLOWED_COMMENTS = %w[
+          :nodoc:
+          :yields:
+          rubocop:disable
+          rubocop:todo
+        ].freeze
 
         def offensive?(comment)
           line = line(comment)

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

@@ -72,12 +72,12 @@ module RuboCop
 
           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)

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

@@ -31,16 +31,22 @@ module RuboCop
 
         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/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_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

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