rubocop 0.72.0 → 0.76.0

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/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/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/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/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/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

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?} ...)