rubocop 1.18.3 → 1.20.0

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

@@ -97,9 +97,9 @@ module RuboCop
       # If a send node contains a heredoc argument, splitting cannot happen
       # after the heredoc or else it will cause a syntax error.
       def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.send_type?
+        return index unless node.send_type? || node.array_type?
 
-        heredoc_index = elements.index { |arg| (arg.str_type? || arg.dstr_type?) && arg.heredoc? }
+        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
         return index unless heredoc_index
         return nil if heredoc_index.zero?
 

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

@@ -5,7 +5,6 @@ module RuboCop
     # Common functionality for checking documentation.
     module DocumentationComment
       extend NodePattern::Macros
-      include Style::AnnotationComment
 
       private
 
@@ -15,7 +14,7 @@ module RuboCop
         return false unless preceding_comment?(node, preceding_lines.last)
 
         preceding_lines.any? do |comment|
-          !annotation?(comment) &&
+          !AnnotationComment.new(comment, annotation_keywords).annotation? &&
             !interpreter_directive_comment?(comment) &&
             !rubocop_directive_comment?(comment)
         end
@@ -44,6 +43,10 @@ module RuboCop
       def rubocop_directive_comment?(comment)
         !!DirectiveComment.new(comment).match_captures
       end
+
+      def annotation_keywords
+        config.for_cop('Style/CommentAnnotation')['Keywords']
+      end
     end
   end
 end

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

@@ -8,7 +8,10 @@ module RuboCop
 
       FROZEN_STRING_LITERAL = '# frozen_string_literal:'
       FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
-      FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
+      FROZEN_STRING_LITERAL_TYPES_RUBY27 = %i[str dstr].freeze
+      FROZEN_STRING_LITERAL_TYPES_RUBY30 = %i[str].freeze
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27, :FROZEN_STRING_LITERAL_TYPES_RUBY30
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
@@ -16,6 +19,16 @@ module RuboCop
 
       private
 
+      def frozen_string_literal?(node)
+        literal_types = if target_ruby_version >= 3.0
+                          FROZEN_STRING_LITERAL_TYPES_RUBY30
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27
+                        end
+
+        literal_types.include?(node.type) && frozen_string_literals_enabled?
+      end
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version

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

@@ -175,7 +175,12 @@ module RuboCop
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          corrector.replace(block_node.body, transforming_body_expr.loc.expression.source)
+          body_source = transforming_body_expr.loc.expression.source
+          if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
+            body_source = "{ #{body_source} }"
+          end
+
+          corrector.replace(block_node.body, body_source)
         end
       end
     end

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

@@ -20,6 +20,13 @@ module RuboCop
 
       private
 
+      def indent_level(str)
+        indentations = str.lines
+                          .map { |line| line[/^\s*/] }
+                          .reject { |line| line.end_with?("\n") }
+        indentations.empty? ? 0 : indentations.min_by(&:size).size
+      end
+
       def delimiter_string(node)
         node.source.match(OPENING_DELIMITER).captures[1]
       end

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/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/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,6 +58,14 @@ 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
 
@@ -123,7 +133,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 +142,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,

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