rubocop 1.18.4 → 1.21.0

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

@@ -18,15 +18,16 @@ module RuboCop
           !parent.parenthesized? && parent&.block_literal?
       end
 
+      # Override to determine values that are invalid in a percent array
+      def invalid_percent_array_contents?(_node)
+        false
+      end
+
       def allowed_bracket_array?(node)
         comments_in_array?(node) || below_array_length?(node) ||
           invalid_percent_array_context?(node)
       end
 
-      def message(_node)
-        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
-      end
-
       def comments_in_array?(node)
         line_span = node.source_range.first_line...node.source_range.last_line
         processed_source.each_comment_in_lines(line_span).any?
@@ -35,9 +36,14 @@ module RuboCop
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
 
-        return unless style == :brackets
+        return unless style == :brackets || invalid_percent_array_contents?(node)
+
+        bracketed_array = build_bracketed_array(node)
+        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
 
-        add_offense(node) { |corrector| correct_bracketed(corrector, node) }
+        add_offense(node, message: message) do |corrector|
+          corrector.replace(node, bracketed_array)
+        end
       end
 
       def check_bracketed_array(node, literal_prefix)
@@ -47,7 +53,7 @@ module RuboCop
 
         return unless style == :percent
 
-        add_offense(node) do |corrector|
+        add_offense(node, message: self.class::PERCENT_MSG) do |corrector|
           percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end

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

@@ -93,7 +93,15 @@ module RuboCop
       end
 
       def aligned_assignment?(range, line)
-        range.source[-1] == '=' && line[range.last_column - 1] == '='
+        (range.source[-1] == '=' && line[range.last_column - 1] == '=') ||
+          aligned_with_append_operator?(range, line)
+      end
+
+      def aligned_with_append_operator?(range, line)
+        last_column = range.last_column
+
+        (range.source == '<<' && line[last_column - 1] == '=') ||
+          (range.source[-1] == '=' && line[(last_column - 2)..(last_column - 1)] == '<<')
       end
 
       def aligned_identical?(range, line)

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Ensure a require statement is present for a standard library determined
+    # by variable library_name
+    module RequireLibrary
+      extend NodePattern::Macros
+
+      def ensure_required(corrector, node, library_name)
+        node = node.parent while node.parent&.parent?
+
+        if node.parent&.begin_type?
+          return if @required_libs.include?(library_name)
+
+          remove_subsequent_requires(corrector, node, library_name)
+        end
+
+        RequireLibraryCorrector.correct(corrector, node, library_name)
+      end
+
+      def remove_subsequent_requires(corrector, node, library_name)
+        node.right_siblings.each do |sibling|
+          next unless require_library_name?(sibling, library_name)
+
+          range = range_by_whole_lines(sibling.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+
+      def on_send(node)
+        return if node.parent&.parent?
+
+        name = require_any_library?(node)
+        return if name.nil?
+
+        @required_libs.add(name)
+      end
+
+      private
+
+      def on_new_investigation
+        # Holds the required files at top-level
+        @required_libs = Set.new
+        super
+      end
+
+      # @!method require_any_library?(node)
+      def_node_matcher :require_any_library?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str $_))
+      PATTERN
+
+      # @!method require_library_name?(node, library_name)
+      def_node_matcher :require_library_name?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str %1))
+      PATTERN
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module RuboCop
       MSG = 'Space found before %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token, pos_before|
+        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
           add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
             PunctuationCorrector.remove_space(corrector, pos_before)
           end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Naming
@@ -90,4 +88,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

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

@@ -54,7 +54,7 @@ module RuboCop
         private
 
         def allowed_assignment?(value)
-          value && %i[block const casgn].include?(value.type) ||
+          (value && %i[block const casgn].include?(value.type)) ||
             allowed_method_call_on_rhs?(value) ||
             class_or_struct_return_method?(value) ||
             allowed_conditional_expression_on_rhs?(value)

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

@@ -19,6 +19,8 @@ module RuboCop
       # Regex can be specified to identify offenses. Suggestions for replacing a flagged term can
       # be configured and will be displayed as part of the offense message.
       # An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term.
+      # `WholeWord: true` can be set on a flagged term to indicate the cop should only match when
+      # a term matches the whole word (partial matches will not be offenses).
       #
       # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
       #   # Suggest replacing identifier whitelist with allowlist
@@ -56,10 +58,20 @@ module RuboCop
       #   # good
       #   # They had a master's degree
       #
+      # @example FlaggedTerms: { slave: { WholeWord: true } }
+      #   # Specify that only terms that are full matches will be flagged.
+      #
+      #   # bad
+      #   Slave
+      #
+      #   # good (won't be flagged despite containing `slave`)
+      #   TeslaVehicle
       class InclusiveLanguage < Base
         include RangeHelp
 
         EMPTY_ARRAY = [].freeze
+        MSG = "Consider replacing '%<term>s'%<suffix>s."
+        MSG_FOR_FILE_PATH = "Consider replacing '%<term>s' in file path%<suffix>s."
 
         WordLocation = Struct.new(:word, :position)
 
@@ -123,7 +135,7 @@ module RuboCop
             next if term_definition.nil?
 
             allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
-            regex_string = ensure_regex_string(term_definition['Regex'] || term)
+            regex_string = ensure_regex_string(extract_regexp(term, term_definition))
             flagged_term_strings << regex_string
 
             add_to_flagged_term_hash(regex_string, term, term_definition)
@@ -132,6 +144,13 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def extract_regexp(term, term_definition)
+          return term_definition['Regex'] if term_definition['Regex']
+          return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']
+
+          term
+        end
+
         def add_to_flagged_term_hash(regex_string, term, term_definition)
           @flagged_term_hash[Regexp.new(regex_string, Regexp::IGNORECASE)] =
             term_definition.merge('Term' => term,
@@ -180,12 +199,11 @@ module RuboCop
         end
 
         def create_single_word_message_for_file(word)
-          create_message(word).sub(/\.$/, ' in file path.')
+          create_message(word, MSG_FOR_FILE_PATH)
         end
 
         def create_multiple_word_message_for_file(words)
-          quoted_words = words.map { |word| "'#{word}'" }
-          "Consider replacing problematic terms #{quoted_words.join(', ')} in file path."
+          format(MSG_FOR_FILE_PATH, term: words.join("', '"), suffix: ' with other terms')
         end
 
         def scan_for_words(input)
@@ -206,9 +224,12 @@ module RuboCop
           safe_str.gsub(@allowed_regex) { |match| '*' * match.size }
         end
 
-        def create_message(word)
+        def create_message(word, message = MSG)
           flagged_term = find_flagged_term(word)
-          "Consider replacing problematic term '#{word}'#{flagged_term['SuggestionString']}."
+          suggestions = flagged_term['SuggestionString']
+          suggestions = ' with another term' if suggestions.blank?
+
+          format(message, term: word, suffix: suggestions)
         end
 
         def find_flagged_term(word)
@@ -218,10 +239,6 @@ module RuboCop
           flagged_term
         end
 
-        def create_message_for_file(word)
-          create_message(word).sub(/\.$/, ' in file path.')
-        end
-
         def preprocess_suggestions(suggestions)
           return '' if suggestions.nil? ||
                        (suggestions.is_a?(String) && suggestions.strip.empty?) || suggestions.empty?

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

@@ -59,8 +59,8 @@ module RuboCop
 
         def check(send_node)
           return if previous_line_comment?(send_node)
-          return unless grouped_style? && sibling_accessors(send_node).size > 1 ||
-                        separated_style? && send_node.arguments.size > 1
+          return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
+                        (separated_style? && send_node.arguments.size > 1)
 
           message = message(send_node)
           add_offense(send_node, message: message) do |corrector|

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

@@ -7,6 +7,10 @@ module RuboCop
       # `||` instead. It can be configured to check only in conditions or in
       # all contexts.
       #
+      # It is marked as unsafe auto-correction because it may change the
+      # operator precedence between logical operators (`&&` and `||`) and
+      # semantic operators (`and` and `or`).
+      #
       # @example EnforcedStyle: always
       #   # bad
       #   foo.save and return

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/AsciiComments
-
 module RuboCop
   module Cop
     module Style
@@ -57,4 +55,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Style/AsciiComments

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

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
       #
+      # Methods that can be either procedural or functional and cannot be
+      # categorised from their usage alone is ignored.
+      # `lambda`, `proc`, and `it` are their defaults.
+      # Additional methods can be added to the `IgnoredMethods`.
+      #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
       #   items.each do |item| item / 5 end
@@ -132,6 +138,17 @@ module RuboCop
       #     puts foo
       #   end
       #
+      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      #
+      #   # good
+      #   foo = lambda do |x|
+      #     puts "Hello, #{x}"
+      #   end
+      #
+      #   foo = lambda do |x|
+      #     x * 100
+      #   end
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods
@@ -175,7 +192,7 @@ module RuboCop
           if node.braces?
             replace_braces_with_do_end(corrector, node.loc)
           else
-            replace_do_end_with_braces(corrector, node.loc)
+            replace_do_end_with_braces(corrector, node)
           end
         end
 
@@ -240,7 +257,8 @@ module RuboCop
           corrector.replace(e, 'end')
         end
 
-        def replace_do_end_with_braces(corrector, loc)
+        def replace_do_end_with_braces(corrector, node)
+          loc = node.loc
           b = loc.begin
           e = loc.end
 
@@ -248,6 +266,8 @@ module RuboCop
 
           corrector.replace(b, '{')
           corrector.replace(e, '}')
+
+          corrector.wrap(node.body, "begin\n", "\nend") if begin_required?(node)
         end
 
         def whitespace_before?(range)
@@ -259,14 +279,20 @@ module RuboCop
         end
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
-          range = range_between(closing_brace.end_pos, comment.loc.expression.end_pos)
-
-          corrector.remove(range_with_surrounding_space(range: range, side: :right))
-          corrector.insert_after(closing_brace, "\n")
+          range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
+          comment_range = range_between(range.end_pos, comment.loc.expression.end_pos)
+          corrector.remove(range_with_surrounding_space(range: comment_range, side: :right))
+          corrector.insert_after(range, "\n")
 
           corrector.insert_before(block_node, "#{comment.text}\n")
         end
 
+        def end_of_chain(node)
+          return node unless node.chained?
+
+          end_of_chain(node.parent)
+        end
+
         def get_blocks(node, &block)
           case node.type
           when :block
@@ -391,7 +417,14 @@ module RuboCop
         def array_or_range?(node)
           node.array_type? || node.range_type?
         end
+
+        def begin_required?(block_node)
+          # If the block contains `rescue` or `ensure`, it needs to be wrapped in
+          # `begin`...`end` when changing `do-end` to `{}`.
+          block_node.each_child_node(:rescue, :ensure).any? && !block_node.single_line?
+        end
       end
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

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

@@ -5,9 +5,11 @@ module RuboCop
     module Style
       # This cop checks for uses of the case equality operator(===).
       #
+      # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
+      # the case equality operator is a constant.
+      #
       # @example
       #   # bad
-      #   Array === something
       #   (1..100) === 7
       #   /something/ === some_string
       #
@@ -16,18 +18,13 @@ module RuboCop
       #   (1..100).include?(7)
       #   /something/.match?(some_string)
       #
-      # @example AllowOnConstant
-      #   # Style/CaseEquality:
-      #   #   AllowOnConstant: true
-      #
+      # @example AllowOnConstant: false (default)
       #   # bad
-      #   (1..100) === 7
-      #   /something/ === some_string
+      #   Array === something
       #
+      # @example AllowOnConstant: true
       #   # good
       #   Array === something
-      #   (1..100).include?(7)
-      #   /something/.match?(some_string)
       #
       class CaseEquality < Base
         extend AutoCorrector

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

@@ -68,7 +68,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/comment_annotation.rb

@@ -6,6 +6,9 @@ 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
@@ -56,7 +59,6 @@ module RuboCop
       #   # good
       #   # OPTIMIZE does not work
       class CommentAnnotation < Base
-        include AnnotationComment
         include RangeHelp
         extend AutoCorrector
 
@@ -73,27 +75,27 @@ module RuboCop
             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)
-
-            range = annotation_range(comment, margin, first_word, colon, space)
+            annotation = AnnotationComment.new(comment, keywords)
+            next unless annotation.annotation? && !annotation.correct?(colon: requires_colon?)
 
-            register_offense(range, note, first_word)
+            register_offense(annotation)
           end
         end
 
         private
 
-        def register_offense(range, note, first_word)
-          message = requires_colon? ? MSG_COLON_STYLE : MSG_SPACE_STYLE
+        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(note ? message : MISSING_NOTE, keyword: first_word)
-          ) do |corrector|
-            next if note.nil?
+          add_offense(range, message: format(message, keyword: annotation.keyword)) do |corrector|
+            next if annotation.note.nil?
 
-            correct_offense(corrector, range, first_word)
+            correct_offense(corrector, range, annotation.keyword)
           end
         end
 
@@ -105,39 +107,23 @@ module RuboCop
           !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)
-        end
-
-        def concat_length(*args)
-          args.reduce(0) { |acc, elem| acc + elem.to_s.length }
+        def annotation_range(annotation)
+          range_between(*annotation.bounds)
         end
 
-        def correct_annotation?(first_word, colon, space, note)
-          return correct_colon_annotation?(first_word, colon, space, note) if requires_colon?
+        def correct_offense(corrector, range, keyword)
+          return corrector.replace(range, "#{keyword.upcase}: ") if requires_colon?
 
-          correct_space_annotation?(first_word, colon, space, note)
-        end
-
-        def correct_colon_annotation?(first_word, colon, space, note)
-          keyword?(first_word) && (colon && space && note || !colon && !note)
-        end
-
-        def correct_space_annotation?(first_word, colon, space, note)
-          keyword?(first_word) && (!colon && space && note || !colon && !note)
-        end
-
-        def correct_offense(corrector, range, first_word)
-          return corrector.replace(range, "#{first_word.upcase}: ") if requires_colon?
-
-          corrector.replace(range, "#{first_word.upcase} ")
+          corrector.replace(range, "#{keyword.upcase} ")
         end
 
         def requires_colon?
           cop_config['RequireColon']
         end
+
+        def keywords
+          cop_config['Keywords']
+        end
       end
     end
   end