rubocop 1.9.1 → 1.22.3

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

@@ -6,6 +6,11 @@ module RuboCop
       # This cop identifies places where `if-elsif` constructions
       # can be replaced with `case-when`.
       #
+      # @safety
+      #   This cop is unsafe. `case` statements use `===` for equality,
+      #   so if the original conditional used a different equality operator, the
+      #   behaviour may be different.
+      #
       # @example
       #   # bad
       #   if status == :active
@@ -105,8 +110,7 @@ module RuboCop
           when :===
             node.arguments.first
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            node.arguments.first if receiver.range_type?
+            find_target_in_include_or_cover_node(node)
           when :match, :match?, :=~
             find_target_in_match_node(node)
           end
@@ -124,6 +128,12 @@ module RuboCop
           end
         end
 
+        def find_target_in_include_or_cover_node(node)
+          return unless (receiver = node.receiver)
+
+          node.first_argument if deparenthesize(receiver).range_type?
+        end
+
         def find_target_in_match_node(node)
           argument = node.arguments.first
           receiver = node.receiver
@@ -167,8 +177,7 @@ module RuboCop
             lhs, _method, rhs = *node
             lhs if rhs == target
           when :include?, :cover?
-            receiver = deparenthesize(node.receiver)
-            receiver if receiver.range_type? && node.arguments.first == target
+            condition_from_include_or_cover_node(node, target)
           end
         end
         # rubocop:enable Metrics/CyclomaticComplexity
@@ -184,6 +193,13 @@ module RuboCop
           condition_from_binary_op(lhs, rhs, target)
         end
 
+        def condition_from_include_or_cover_node(node, target)
+          return unless (receiver = node.receiver)
+
+          receiver = deparenthesize(receiver)
+          receiver if receiver.range_type? && node.first_argument == target
+        end
+
         def condition_from_binary_op(lhs, rhs, target)
           lhs = deparenthesize(lhs)
           rhs = deparenthesize(rhs)
@@ -210,8 +226,7 @@ module RuboCop
           name = node.children[1].to_s
 
           # We can no be sure if, e.g. `C`, represents a constant or a class reference
-          name.length > 1 &&
-            name == name.upcase
+          name.length > 1 && name == name.upcase
         end
 
         def class_reference?(node)

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

@@ -18,13 +18,11 @@ module RuboCop
         include StringHelp
         extend AutoCorrector
 
-        MSG = 'Do not use the character literal - ' \
-              'use string literal instead.'
+        MSG = 'Do not use the character literal - use string literal instead.'
 
         def offense?(node)
           # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') &&
-            node.source.size.between?(2, 3)
+          node.loc.begin.is?('?') && node.source.size.between?(2, 3)
         end
 
         def autocorrect(corrector, node)

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

@@ -6,6 +6,15 @@ module RuboCop
       # This cop checks the style of children definitions at classes and
       # modules. Basically there are two different styles:
       #
+      # @safety
+      #   Autocorrection is unsafe.
+      #
+      #   Moving from compact to nested children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   verification that the outer parent is defined elsewhere. Rubocop does not
+      #   have the knowledge to perform either operation safely and thus requires
+      #   manual oversight.
+      #
       # @example EnforcedStyle: nested (default)
       #   # good
       #   # have each child on its own line
@@ -26,10 +35,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'
-        COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'
+        NESTED_MSG = 'Use nested module/class definitions instead of compact style.'
+        COMPACT_MSG = 'Use compact module/class definition instead of nested style.'
 
         def on_class(node)
           return if node.parent_class && style != :nested
@@ -86,13 +93,22 @@ module RuboCop
         def compact_definition(corrector, node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
+          unindent(corrector, node)
         end
 
         def compact_node(corrector, node)
+          range = range_between(node.loc.keyword.begin_pos, node.body.loc.name.end_pos)
+          corrector.replace(range, compact_replacement(node))
+        end
+
+        def compact_replacement(node)
           replacement = "#{node.body.type} #{compact_identifier_name(node)}"
-          range = range_between(node.loc.keyword.begin_pos,
-                                node.body.loc.name.end_pos)
-          corrector.replace(range, replacement)
+
+          body_comments = processed_source.ast_with_comments[node.body]
+          unless body_comments.empty?
+            replacement = body_comments.map(&:text).push(replacement).join("\n")
+          end
+          replacement
         end
 
         def compact_identifier_name(node)
@@ -108,6 +124,19 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def configured_indentation_width
+          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
+        end
+
+        def unindent(corrector, node)
+          return if node.body.children.last.nil?
+
+          column_delta = configured_indentation_width - leading_spaces(node.body.children.last).size
+          return if column_delta.zero?
+
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end
@@ -135,7 +164,10 @@ module RuboCop
         end
 
         def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
+          parent = node.parent
+          return if parent&.class_type? || parent&.module_type?
+
+          return unless needs_compacting?(body)
 
           add_offense(node.loc.name, message: COMPACT_MSG) do |corrector|
             autocorrect(corrector, node)
@@ -148,12 +180,12 @@ module RuboCop
           nest_or_compact(corrector, node)
         end
 
-        def one_child?(body)
+        def needs_compacting?(body)
           body && %i[module class].include?(body.type)
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.loc.name.source)
+          /::/.match?(node.identifier.source)
         end
       end
     end

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

@@ -25,6 +25,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[== equal? eql?].freeze
 
+        # @!method class_comparison_candidate?(node)
         def_node_matcher :class_comparison_candidate?, <<~PATTERN
           (send
             {$(send _ :class) (send $(send _ :class) :name)}
@@ -49,6 +50,8 @@ module RuboCop
 
         def class_name(class_node, node)
           if node.children.first.method?(:name)
+            return class_node.receiver.source if class_node.receiver
+
             class_node.source.delete('"').delete("'")
           else
             class_node.source

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

@@ -31,9 +31,7 @@ module RuboCop
           if node.body.defs_type?
             check_defs(node.identifier, node.body)
           elsif node.body.begin_type?
-            node.body.each_child_node(:defs) do |def_node|
-              check_defs(node.identifier, def_node)
-            end
+            node.body.each_child_node(:defs) { |def_node| check_defs(node.identifier, def_node) }
           end
         end
         alias on_module on_class

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

@@ -6,11 +6,13 @@ module RuboCop
       # This cop checks for places where custom logic on rejection nils from arrays
       # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
       #
-      # It is marked as unsafe by default because false positives may occur in the
-      # nil check of block arguments to the receiver object.
-      # For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
-      # and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
-      # when the receiver is a hash object.
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   `nil` check of block arguments to the receiver object.
+      #
+      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.nil? }`
+      #   and `[[1, 2], [3, nil]].compact` are not compatible. This will work fine
+      #   when the receiver is a hash object.
       #
       # @example
       #   # bad
@@ -35,6 +37,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
 
+        # @!method reject_method?(node)
         def_node_matcher :reject_method?, <<~PATTERN
           (block
             (send
@@ -44,6 +47,7 @@ module RuboCop
               $(lvar _) :nil?))
         PATTERN
 
+        # @!method select_method?(node)
         def_node_matcher :select_method?, <<~PATTERN
           (block
             (send
@@ -67,9 +71,7 @@ module RuboCop
           good = good_method_name(method_name)
           message = format(MSG, good: good, bad: range.source)
 
-          add_offense(range, message: message) do |corrector|
-            corrector.replace(range, good)
-          end
+          add_offense(range, message: message) { |corrector| corrector.replace(range, good) }
         end
 
         private

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

@@ -6,10 +6,6 @@ module RuboCop
       # This cop enforces the use of consistent method names
       # from the Enumerable module.
       #
-      # Unfortunately we cannot actually know if a method is from
-      # Enumerable or not (static analysis limitation), so this cop
-      # can yield some false positives.
-      #
       # You can customize the mapping from undesired method to desired method.
       #
       # e.g. to use `detect` over `find`:
@@ -18,9 +14,14 @@ module RuboCop
       #     PreferredMethods:
       #       find: detect
       #
-      # The default mapping for `PreferredMethods` behaves as follows.
+      # @safety
+      #   This cop is unsafe because it finds methods by name, without actually
+      #   being able to determine if the receiver is an Enumerable or not, so
+      #   this cop may register false positives.
       #
       # @example
+      #   # These examples are based on the default mapping for `PreferredMethods`.
+      #
       #   # bad
       #   items.collect
       #   items.collect!
@@ -68,7 +69,8 @@ module RuboCop
           return false unless node.arguments.any?
 
           node.last_argument.block_pass_type? ||
-            node.last_argument.sym_type? && methods_accepting_symbol.include?(node.method_name.to_s)
+            (node.last_argument.sym_type? &&
+            methods_accepting_symbol.include?(node.method_name.to_s))
         end
 
         def message(node)

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

@@ -22,6 +22,7 @@ module RuboCop
 
         MSG = 'Do not use `::` for method calls.'
 
+        # @!method java_type_node?(node)
         def_node_matcher :java_type_node?, <<~PATTERN
           (send
             (const nil? :Java) _)
@@ -37,9 +38,7 @@ module RuboCop
           # ignore Java interop code like Java::int
           return if java_type_node?(node)
 
-          add_offense(node.loc.dot) do |corrector|
-            corrector.replace(node.loc.dot, '.')
-          end
+          add_offense(node.loc.dot) { |corrector| corrector.replace(node.loc.dot, '.') }
         end
       end
     end

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

@@ -7,8 +7,9 @@ module RuboCop
       # can be combined into a single loop. It is very likely that combining them
       # will make the code more efficient and more concise.
       #
-      # It is marked as unsafe, because the first loop might modify
-      # a state that the second loop depends on; these two aren't combinable.
+      # @safety
+      #   The cop is unsafe, because the first loop might modify state that the
+      #   second loop depends on; these two aren't combinable.
       #
       # @example
       #   # bad
@@ -75,8 +76,9 @@ module RuboCop
         private
 
         def collection_looping_method?(node)
-          method_name = node.send_node.method_name
-          method_name.match?(/^each/) || method_name.match?(/_each$/)
+          # TODO: Remove `Symbol#to_s` after supporting only Ruby >= 2.7.
+          method_name = node.send_node.method_name.to_s
+          method_name.start_with?('each') || method_name.end_with?('_each')
         end
 
         def same_collection_looping?(node, sibling)

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

@@ -97,17 +97,13 @@ module RuboCop
         def check_backtick_literal(node, message)
           return if allowed_backtick_literal?(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def check_percent_x_literal(node, message)
           return if allowed_percent_x_literal?(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -165,7 +161,7 @@ module RuboCop
         end
 
         def preferred_delimiter
-          (command_delimiter || default_delimiter).split(//)
+          (command_delimiter || default_delimiter).chars
         end
 
         def command_delimiter
@@ -177,8 +173,7 @@ module RuboCop
         end
 
         def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
         end
       end
     end

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

@@ -6,13 +6,16 @@ module RuboCop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # Annotation keywords can be specified by overriding the cop's `Keywords`
+      # configuration. Keywords are allowed to be single words or phrases.
+      #
       # NOTE: With a multiline comment block (where each line is only a
       # comment), only the first line will be able to register an offense, even
       # if an annotation keyword starts another line. This is done to prevent
       # incorrect registering of keywords (eg. `review`) inside a paragraph as an
       # annotation.
       #
-      # @example
+      # @example RequireColon: true (default)
       #   # bad
       #   # TODO make better
       #
@@ -36,66 +39,90 @@ module RuboCop
       #
       #   # good
       #   # OPTIMIZE: does not work
+      #
+      # @example RequireColon: false
+      #   # bad
+      #   # TODO: make better
+      #
+      #   # good
+      #   # TODO make better
+      #
+      #   # bad
+      #   # fixme does not work
+      #
+      #   # good
+      #   # FIXME does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE does not work
       class CommentAnnotation < Base
-        include AnnotationComment
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
-              'upper case, followed by a colon, and a space, ' \
-              'then a note describing the problem.'
-        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
-                       'is missing a note.'
+        MSG_COLON_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a colon, and a space, ' \
+                          'then a note describing the problem.'
+        MSG_SPACE_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a space, ' \
+                          'then a note describing the problem.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, is missing a note.'
 
         def on_new_investigation
           processed_source.comments.each_with_index do |comment, index|
             next unless first_comment_line?(processed_source.comments, index) ||
                         inline_comment?(comment)
 
-            margin, first_word, colon, space, note = split_comment(comment)
-            next unless annotation?(comment) &&
-                        !correct_annotation?(first_word, colon, space, note)
+            annotation = AnnotationComment.new(comment, keywords)
+            next unless annotation.annotation? && !annotation.correct?(colon: requires_colon?)
 
-            range = annotation_range(comment, margin, first_word, colon, space)
-
-            register_offense(range, note, first_word)
+            register_offense(annotation)
           end
         end
 
         private
 
-        def register_offense(range, note, first_word)
-          add_offense(
-            range,
-            message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
-          ) do |corrector|
-            next if note.nil?
+        def register_offense(annotation)
+          range = annotation_range(annotation)
+          message = if annotation.note
+                      requires_colon? ? MSG_COLON_STYLE : MSG_SPACE_STYLE
+                    else
+                      MISSING_NOTE
+                    end
+
+          add_offense(range, message: format(message, keyword: annotation.keyword)) do |corrector|
+            next if annotation.note.nil?
 
-            corrector.replace(range, "#{first_word.upcase}: ")
+            correct_offense(corrector, range, annotation.keyword)
           end
         end
 
         def first_comment_line?(comments, index)
-          index.zero? ||
-            comments[index - 1].loc.line < comments[index].loc.line - 1
+          index.zero? || comments[index - 1].loc.line < comments[index].loc.line - 1
         end
 
         def inline_comment?(comment)
           !comment_line?(comment.loc.expression.source_line)
         end
 
-        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)
+        def annotation_range(annotation)
+          range_between(*annotation.bounds)
+        end
+
+        def correct_offense(corrector, range, keyword)
+          return corrector.replace(range, "#{keyword.upcase}: ") if requires_colon?
+
+          corrector.replace(range, "#{keyword.upcase} ")
         end
 
-        def concat_length(*args)
-          args.reduce(0) { |acc, elem| acc + elem.to_s.length }
+        def requires_colon?
+          cop_config['RequireColon']
         end
 
-        def correct_annotation?(first_word, colon, space, note)
-          keyword?(first_word) && (colon && space && note || !colon && !note)
+        def keywords
+          cop_config['Keywords']
         end
       end
     end

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

@@ -13,6 +13,10 @@ module RuboCop
       # Auto-correction removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
       #
+      # @safety
+      #   Auto-correction is unsafe because it may remove a comment that is
+      #   meaningful.
+      #
       # @example
       #   # bad
       #   if condition
@@ -40,12 +44,19 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not place comments on the same line as the ' \
-              '`%<keyword>s` keyword.'
+        MSG = 'Do not place comments on the same line as the `%<keyword>s` keyword.'
+
+        KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
+        ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable rubocop:todo].freeze
+        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
+
+        REGEXP = /(?<keyword>\S+).*#/.freeze
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
+            next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
 
             register_offense(comment, match[:keyword])
           end
@@ -53,17 +64,6 @@ module RuboCop
 
         private
 
-        KEYWORDS = %w[begin class def end module].freeze
-        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
-
-        ALLOWED_COMMENTS = %w[
-          :nodoc:
-          :yields:
-          rubocop:disable
-          rubocop:todo
-        ].freeze
-        ALLOWED_COMMENT_REGEXES = ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ }.freeze
-
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
             range = range_with_surrounding_space(range: comment.loc.expression, newlines: false)
@@ -78,12 +78,12 @@ module RuboCop
         end
 
         def offensive?(comment)
-          line = line(comment)
+          line = source_line(comment)
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
-        def line(comment)
+        def source_line(comment)
           comment.location.expression.source_line
         end
       end