rubocop 0.73.0 → 0.77.0

data/lib/rubocop/cop/naming/heredoc_delimiter_naming.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Naming
       # This cop checks that your heredocs are using meaningful delimiters.
       # By default it disallows `END` and `EO*`, and can be configured through
-      # blacklisting additional delimiters.
+      # forbidden listing additional delimiters.
       #
       # @example
       #
@@ -41,13 +41,13 @@ module RuboCop
 
           return false unless delimiters =~ /\w/
 
-          blacklisted_delimiters.none? do |blacklisted_delimiter|
-            delimiters =~ Regexp.new(blacklisted_delimiter)
+          forbidden_delimiters.none? do |forbidden_delimiter|
+            delimiters =~ Regexp.new(forbidden_delimiter)
           end
         end
 
-        def blacklisted_delimiters
-          cop_config['Blacklist'] || []
+        def forbidden_delimiters
+          cop_config['ForbiddenDelimiters'] || []
         end
       end
     end

data/lib/rubocop/cop/naming/method_name.rb

@@ -6,6 +6,15 @@ module RuboCop
       # This cop makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
+      # This cop has `IgnoredPatterns` configuration option.
+      #
+      #   Naming/MethodName:
+      #     IgnoredPatterns:
+      #       - '\A\s*onSelectionBulkChange\s*'
+      #       - '\A\s*onSelectionCleared\s*'
+      #
+      # Method names matching patterns are always allowed.
+      #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
       #   def fooBar; end
@@ -21,11 +30,13 @@ module RuboCop
       #   def fooBar; end
       class MethodName < Cop
         include ConfigurableNaming
+        include IgnoredPattern
 
         MSG = 'Use %<style>s for method names.'
 
         def on_def(node)
-          return if node.operator_method?
+          return if node.operator_method? ||
+                    matches_ignored_pattern?(node.method_name)
 
           check_name(node, node.method_name, node.loc.name)
         end

data/lib/rubocop/cop/naming/{uncommunicative_method_param_name.rb → method_parameter_name.rb}

@@ -11,9 +11,9 @@ module RuboCop
       # The `AllowNamesEndingInNumbers` config option takes a boolean. When
       # set to false, this cop will register offenses for names ending with
       # numbers. Its default is false. The `AllowedNames` config option
-      # takes an array of whitelisted names that will never register an
+      # takes an array of permitted names that will never register an
       # offense. The `ForbiddenNames` config option takes an array of
-      # blacklisted names that will always register an offense.
+      # restricted names that will always register an offense.
       #
       # @example
       #   # bad
@@ -43,7 +43,7 @@ module RuboCop
       #   def baz(age_a, height_b, gender_c)
       #     do_stuff(age_a, height_b, gender_c)
       #   end
-      class UncommunicativeMethodParamName < Cop
+      class MethodParameterName < Cop
         include UncommunicativeName
 
         def on_def(node)

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -70,11 +70,11 @@ module RuboCop
           !method_name.match(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
-            predicate_whitelist.include?(method_name)
+            allowed_methods.include?(method_name)
         end
 
         def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
+          new_name = if forbidden_prefixes.include?(prefix)
                        method_name.sub(prefix, '')
                      else
                        method_name.dup
@@ -87,16 +87,16 @@ module RuboCop
           "Rename `#{method_name}` to `#{new_name}`."
         end
 
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
+        def forbidden_prefixes
+          cop_config['ForbiddenPrefixes']
         end
 
         def predicate_prefixes
           cop_config['NamePrefix']
         end
 
-        def predicate_whitelist
-          cop_config['NameWhitelist']
+        def allowed_methods
+          cop_config['AllowedMethods']
         end
 
         def method_definition_macros(macro_name)

data/lib/rubocop/cop/naming/variable_name.rb

@@ -39,6 +39,7 @@ module RuboCop
         alias on_kwarg     on_lvasgn
         alias on_kwrestarg on_lvasgn
         alias on_blockarg  on_lvasgn
+        alias on_lvar      on_lvasgn
 
         private
 

data/lib/rubocop/cop/offense.rb

@@ -67,23 +67,34 @@ module RuboCop
 
       # @api public
       #
-      # @!attribute [r] corrected
+      # @!attribute [r] corrected?
       #
       # @return [Boolean]
-      #   whether this offense is automatically corrected.
-      def corrected
-        @status == :corrected
+      #   whether this offense is automatically corrected via
+      #   autocorrect or a todo.
+      def corrected?
+        @status == :corrected || @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected_with_todo?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically disabled via a todo.
+      def corrected_with_todo?
+        @status == :corrected_with_todo
       end
-      alias corrected? corrected
 
       # @api public
       #
       # @!attribute [r] disabled?
       #
       # @return [Boolean]
-      #   whether this offense was locally disabled where it occurred
+      #   whether this offense was locally disabled with a
+      #   disable or todo where it occurred.
       def disabled?
-        @status == :disabled
+        @status == :disabled || @status == :todo
       end
 
       # @api public

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) }) <<
+          'RedundantCopDisableDirective'
+      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/alias.rb

@@ -91,7 +91,7 @@ module RuboCop
             when :def, :defs
               return :dynamic
             when :block
-              return :instance_eval if parent.method_name == :instance_eval
+              return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic
             end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of "*" as a substitute for *join*.
+      # This cop checks for uses of "\*" as a substitute for *join*.
       #
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an

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

@@ -31,7 +31,7 @@ module RuboCop
           node_expr = node.source_range
           attr_expr = attr_name.source_range
 
-          if setter && (setter.true_type? || setter.false_type?)
+          if setter&.boolean_type?
             remove = range_between(attr_expr.end_pos, node_expr.end_pos)
           end
 
@@ -50,7 +50,7 @@ module RuboCop
         def replacement_method(node)
           setter = node.last_argument
 
-          if setter && (setter.true_type? || setter.false_type?)
+          if setter&.boolean_type?
             setter.true_type? ? 'attr_accessor' : 'attr_reader'
           else
             'attr_reader'

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,
@@ -128,16 +147,16 @@ module RuboCop
         end
 
         def remove_braces_with_whitespace(corrector, node, space)
+          loc = node.loc
+
           if node.multiline?
             remove_braces_with_range(corrector,
-                                     left_whole_line_range(node.loc.begin),
-                                     right_whole_line_range(node.loc.end))
+                                     left_whole_line_range(loc.begin),
+                                     right_whole_line_range(loc.end))
           else
-            right_brace_and_space = right_brace_and_space(node.loc.end, space)
-            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
             remove_braces_with_range(corrector,
-                                     left_brace_and_space,
-                                     right_brace_and_space)
+                                     left_brace_and_space(loc.begin, space),
+                                     right_brace_and_space(loc.end, space))
           end
         end
 

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/comment_annotation.rb

@@ -49,10 +49,10 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            length = concat_length(first_word, colon, space)
             add_offense(
               comment,
-              location: annotation_range(comment, margin, length),
+              location: annotation_range(comment, margin,
+                                         first_word, colon, space),
               message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
             )
           end
@@ -62,8 +62,7 @@ module RuboCop
           margin, first_word, colon, space, note = split_comment(comment)
           return if note.nil?
 
-          length = concat_length(first_word, colon, space)
-          range = annotation_range(comment, margin, length)
+          range = annotation_range(comment, margin, first_word, colon, space)
 
           ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
@@ -79,8 +78,9 @@ module RuboCop
           !comment_line?(comment.loc.expression.source_line)
         end
 
-        def annotation_range(comment, margin, length)
+        def annotation_range(comment, margin, first_word, colon, space)
           start = comment.loc.expression.begin_pos + margin.length
+          length = concat_length(first_word, colon, space)
           range_between(start, start + length)
         end
 

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
@@ -33,53 +34,38 @@ module RuboCop
       #     y
       #   end
       class CommentedKeyword < Cop
-        include RangeHelp
-
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
         def investigate(processed_source)
-          heredoc_lines = extract_heredoc_lines(processed_source.ast)
-
           processed_source.each_comment do |comment|
-            location = comment.location
-            line_position = location.line
-            line = processed_source.lines[line_position - 1]
-            next if heredoc_lines.any? { |r| r.include?(line_position) }
-            next unless offensive?(line)
-
-            range = source_range(processed_source.buffer,
-                                 line_position,
-                                 (location.column)...(location.last_column))
-
-            add_offense(range, location: range)
+            add_offense(comment) if offensive?(comment)
           end
         end
 
         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?(line)
-          line = line.lstrip
-          KEYWORDS.any? { |word| line =~ /^#{word}\s/ } &&
+        def offensive?(comment)
+          line = line(comment)
+          KEYWORDS.any? { |word| line =~ /^\s*#{word}\s/ } &&
             ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
         end
 
-        def message(node)
-          line = node.source_line
-          keyword = /^\s*(\S+).*#/.match(line)[1]
+        def message(comment)
+          keyword = line(comment).match(/(\S+).*#/)[1]
           format(MSG, keyword: keyword)
         end
 
-        def extract_heredoc_lines(ast)
-          return [] unless ast
-
-          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
-            body = node.location.heredoc_body
-            (body.first_line...body.last_line)
-          end
+        def line(comment)
+          comment.location.expression.source_line
         end
       end
     end