rubocop 0.71.0 → 0.75.1

data/lib/rubocop/cop/mixin/safe_mode.rb

@@ -3,6 +3,8 @@
 module RuboCop
   module Cop
     # Common functionality for Rails safe mode.
+    #
+    # This module can be removed from RuboCop 0.76.
     module SafeMode
       private
 

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -9,6 +9,8 @@ module RuboCop
       NO_SPACE_COMMAND = 'Do not use'
       SPACE_COMMAND = 'Use'
 
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
+
       private
 
       def side_space_range(range:, side:)
@@ -18,11 +20,11 @@ module RuboCop
         begin_pos = range.begin_pos
         end_pos = range.end_pos
         if side == :left
+          end_pos = begin_pos
           begin_pos = reposition(src, begin_pos, -1)
-          end_pos -= 1
         end
         if side == :right
-          begin_pos += 1
+          begin_pos = end_pos
           end_pos = reposition(src, end_pos, 1)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
@@ -85,15 +87,15 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) == ' '
+          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
         else
-          String(token.space_before?) == ' '
+          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
         end
       end
 
       def reposition(src, pos, step)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ /[ \t]/
+        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
         pos.negative? ? 0 : pos
       end
 

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

@@ -20,7 +20,7 @@ module RuboCop
         OP_LIKE_METHODS = %i[eql? equal?].freeze
         BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
 
-        def_node_matcher :op_method_candidate?, <<-PATTERN
+        def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
         PATTERN
 

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

@@ -23,7 +23,7 @@ module RuboCop
         # than just standard ASCII characters
         SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
 
-        def_node_matcher :class_or_struct_return_method?, <<-PATTERN
+        def_node_matcher :class_or_struct_return_method?, <<~PATTERN
           (send
             (const _ {:Class :Struct}) :new
             ...)
@@ -63,7 +63,7 @@ module RuboCop
             (node.receiver.nil? || !literal_receiver?(node))
         end
 
-        def_node_matcher :literal_receiver?, <<-PATTERN
+        def_node_matcher :literal_receiver?, <<~PATTERN
           {(send literal? ...)
            (send (begin literal?) ...)}
         PATTERN

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

@@ -28,7 +28,7 @@ module RuboCop
       #   def value?
       #   end
       class PredicateName < Cop
-        def_node_matcher :dynamic_method_define, <<-PATTERN
+        def_node_matcher :dynamic_method_define, <<~PATTERN
           (send nil? #method_definition_macros
             (sym $_)
             ...)

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

@@ -57,24 +57,20 @@ module RuboCop
         MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'
 
         def on_resbody(node)
-          exception_type, @exception_name = *node
-          return unless exception_type || @exception_name
-
-          @exception_name ||= exception_type.children.first
-          return if @exception_name.const_type? ||
-                    variable_name == preferred_name
+          name = variable_name(node)
+          return unless name
+          return if preferred_name(name).to_sym == name
 
           add_offense(node, location: offense_range(node))
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            offending_name = node.exception_variable.children.first
+            offending_name = variable_name(node)
+            preferred_name = preferred_name(offending_name)
             corrector.replace(offense_range(node), preferred_name)
 
-            return unless node.body
-
-            node.body.each_descendant(:lvar) do |var|
+            node.body&.each_descendant(:lvar) do |var|
               next unless var.children.first == offending_name
 
               corrector.replace(var.loc.expression, preferred_name)
@@ -89,21 +85,26 @@ module RuboCop
           variable.loc.expression
         end
 
-        def preferred_name
-          name = cop_config.fetch('PreferredName', 'e')
-          variable_name.to_s.start_with?('_') ? "_#{name}" : name
+        def preferred_name(variable_name)
+          preferred_name = cop_config.fetch('PreferredName', 'e')
+          if variable_name.to_s.start_with?('_')
+            "_#{preferred_name}"
+          else
+            preferred_name
+          end
         end
 
-        def variable_name
-          location.source
-        end
+        def variable_name(node)
+          asgn_node = node.exception_variable
+          return unless asgn_node
 
-        def location
-          @exception_name.loc.expression
+          asgn_node.children.last
         end
 
-        def message(_node = nil)
-          format(MSG, preferred: preferred_name, bad: variable_name)
+        def message(node)
+          offending_name = variable_name(node)
+          preferred_name = preferred_name(offending_name)
+          format(MSG, preferred: preferred_name, bad: offending_name)
         end
       end
     end

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) }) <<
+          'UnneededCopDisableDirective'
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
         @cops_by_cop_name

data/lib/rubocop/cop/security/eval.rb

@@ -14,7 +14,7 @@ module RuboCop
       class Eval < Cop
         MSG = 'The use of `eval` is a serious security risk.'
 
-        def_node_matcher :eval?, <<-PATTERN
+        def_node_matcher :eval?, <<~PATTERN
           (send {nil? (send nil? :binding)} :eval $!str ...)
         PATTERN
 

data/lib/rubocop/cop/security/json_load.rb

@@ -25,7 +25,7 @@ module RuboCop
       class JSONLoad < Cop
         MSG = 'Prefer `JSON.parse` over `JSON.%<method>s`.'
 
-        def_node_matcher :json_load, <<-PATTERN
+        def_node_matcher :json_load, <<~PATTERN
           (send (const {nil? cbase} :JSON) ${:load :restore} ...)
         PATTERN
 

data/lib/rubocop/cop/security/marshal_load.rb

@@ -21,7 +21,7 @@ module RuboCop
       class MarshalLoad < Cop
         MSG = 'Avoid using `Marshal.%<method>s`.'
 
-        def_node_matcher :marshal_load, <<-PATTERN
+        def_node_matcher :marshal_load, <<~PATTERN
           (send (const {nil? cbase} :Marshal) ${:load :restore}
           !(send (const {nil? cbase} :Marshal) :dump ...))
         PATTERN

data/lib/rubocop/cop/security/open.rb

@@ -22,7 +22,7 @@ module RuboCop
       class Open < Cop
         MSG = 'The use of `Kernel#open` is a serious security risk.'
 
-        def_node_matcher :open?, <<-PATTERN
+        def_node_matcher :open?, <<~PATTERN
           (send nil? :open $!str ...)
         PATTERN
 

data/lib/rubocop/cop/security/yaml_load.rb

@@ -18,7 +18,7 @@ module RuboCop
       class YAMLLoad < Cop
         MSG = 'Prefer using `YAML.safe_load` over `YAML.load`.'
 
-        def_node_matcher :yaml_load, <<-PATTERN
+        def_node_matcher :yaml_load, <<~PATTERN
           (send (const {nil? cbase} :YAML) :load ...)
         PATTERN
 

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

@@ -138,7 +138,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :identifier, <<-PATTERN
+        def_node_matcher :identifier, <<~PATTERN
           (sym $_)
         PATTERN
       end

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

@@ -20,7 +20,7 @@ module RuboCop
       class ColonMethodCall < Cop
         MSG = 'Do not use `::` for method calls.'
 
-        def_node_matcher :java_type_node?, <<-PATTERN
+        def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)
         PATTERN

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