rubocop 1.19.0 → 1.23.0

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

@@ -2,40 +2,63 @@
 
 module RuboCop
   module Cop
-    module Style
-      # Common functionality related to annotation comments.
-      module AnnotationComment
-        private
-
-        # @api public
-        def annotation?(comment)
-          _margin, first_word, colon, space, note = split_comment(comment)
-          keyword_appearance?(first_word, colon, space) &&
-            !just_first_word_of_sentence?(first_word, colon, space, note)
-        end
-
-        # @api public
-        def split_comment(comment)
-          match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
-          return false unless match
-
-          match.captures
-        end
-
-        # @api public
-        def keyword_appearance?(first_word, colon, space)
-          first_word && keyword?(first_word.upcase) && (colon || space)
-        end
-
-        # @api private
-        def just_first_word_of_sentence?(first_word, colon, space, note)
-          first_word == first_word.capitalize && !colon && space && note
-        end
-
-        # @api public
-        def keyword?(word)
-          config.for_cop('Style/CommentAnnotation')['Keywords'].include?(word)
-        end
+    # Representation of an annotation comment in source code (eg. `# TODO: blah blah blah`).
+    class AnnotationComment
+      extend Forwardable
+
+      attr_reader :comment, :margin, :keyword, :colon, :space, :note
+
+      # @param [Parser::Source::Comment] comment
+      # @param [Array<String>] keywords
+      def initialize(comment, keywords)
+        @comment = comment
+        @keywords = keywords
+        @margin, @keyword, @colon, @space, @note = split_comment(comment)
+      end
+
+      def annotation?
+        keyword_appearance? && !just_keyword_of_sentence?
+      end
+
+      def correct?(colon:)
+        return false unless keyword && space && note
+        return false unless keyword == keyword.upcase
+
+        self.colon.nil? == !colon
+      end
+
+      # Returns the range bounds for just the annotation
+      def bounds
+        start = comment.loc.expression.begin_pos + margin.length
+        length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
+        [start, start + length]
+      end
+
+      private
+
+      attr_reader :keywords
+
+      def split_comment(comment)
+        # Sort keywords by reverse length so that if a keyword is in a phrase
+        # but also on its own, both will match properly.
+        keywords_regex = Regexp.new(
+          Regexp.union(keywords.sort_by { |w| -w.length }).source,
+          Regexp::IGNORECASE
+        )
+        regex = /^(# ?)(\b#{keywords_regex}\b)(\s*:)?(\s+)?(\S+)?/i
+
+        match = comment.text.match(regex)
+        return false unless match
+
+        match.captures
+      end
+
+      def keyword_appearance?
+        keyword && (colon || space)
+      end
+
+      def just_keyword_of_sentence?
+        keyword == keyword.capitalize && !colon && space && note
       end
     end
   end

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

@@ -43,7 +43,7 @@ module RuboCop
 
       # Returns true for lines that shall not be included in the count.
       def irrelevant_line(source_line)
-        source_line.blank? || !count_comments? && comment_line?(source_line)
+        source_line.blank? || (!count_comments? && comment_line?(source_line))
       end
 
       def build_code_length_calculator(node)

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

@@ -34,8 +34,7 @@ module RuboCop
 
       def matching_ranges(end_loc, align_ranges)
         align_ranges.select do |_, range|
-          range.line == end_loc.line ||
-            column_offset_between(range, end_loc).zero?
+          same_line?(range, end_loc) || column_offset_between(range, end_loc).zero?
         end
       end
 

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

@@ -8,7 +8,9 @@ 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
+
+      private_constant :FROZEN_STRING_LITERAL_TYPES_RUBY27
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? { |line| MagicComment.parse(line).valid_literal_value? }
@@ -16,6 +18,26 @@ module RuboCop
 
       private
 
+      def frozen_string_literal?(node)
+        frozen_string = if target_ruby_version >= 3.0
+                          uninterpolated_string?(node) || frozen_heredoc?(node)
+                        else
+                          FROZEN_STRING_LITERAL_TYPES_RUBY27.include?(node.type)
+                        end
+
+        frozen_string && frozen_string_literals_enabled?
+      end
+
+      def uninterpolated_string?(node)
+        node.str_type? || (node.dstr_type? && node.each_descendant(:begin).none?)
+      end
+
+      def frozen_heredoc?(node)
+        return false unless node.dstr_type? && node.heredoc?
+
+        node.children.all?(&:str_type?)
+      end
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking gem declarations.
+    module GemspecHelp
+      extend NodePattern::Macros
+
+      # @!method gem_specification?(node)
+      def_node_matcher :gem_specification?, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+
+      # @!method gem_specification(node)
+      def_node_search :gem_specification, <<~PATTERN
+        (block
+          (send
+            (const
+              (const {cbase nil?} :Gem) :Specification) :new)
+          (args
+            (arg $_)) ...)
+      PATTERN
+    end
+  end
+end

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

@@ -139,9 +139,9 @@ module RuboCop
         end
 
         def self.from_map_to_h(node, match)
-          strip_trailing_chars = 0
-
-          unless node.parent&.block_type?
+          if node.parent&.block_type? && node.parent.send_node == node
+            strip_trailing_chars = 0
+          else
             map_range = node.children.first.source_range
             node_range = node.source_range
             strip_trailing_chars = node_range.end_pos - map_range.end_pos

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

@@ -21,9 +21,7 @@ module RuboCop
       private
 
       def indent_level(str)
-        indentations = str.lines
-                          .map { |line| line[/^\s*/] }
-                          .reject { |line| line.end_with?("\n") }
+        indentations = str.lines.map { |line| line[/^\s*/] }.reject { |line| line.end_with?("\n") }
         indentations.empty? ? 0 : indentations.min_by(&:size).size
       end
 

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

@@ -15,7 +15,7 @@ module RuboCop
         node.arguments.each do |arg|
           on_node(type, arg, :send) do |type_node|
             left_brace = type_node.loc.begin
-            if left_brace && left_brace.line == left_parenthesis.line
+            if left_brace && same_line?(left_brace, left_parenthesis)
               yield type_node, left_parenthesis
               ignore_node(type_node)
             end

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

@@ -134,7 +134,7 @@ module RuboCop
 
           next if a.setter_method?
           next unless kind == :with_or_without_parentheses ||
-                      kind == :with_parentheses && parentheses?(a)
+                      (kind == :with_parentheses && parentheses?(a))
 
           a.arguments.any? { |arg| within_node?(node, arg) }
         end
@@ -156,7 +156,7 @@ module RuboCop
 
       def disqualified_rhs?(candidate, ancestor)
         UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
-          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+          (ancestor.block_type? && part_of_block_body?(candidate, ancestor))
       end
 
       def valid_rhs?(candidate, ancestor)

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

@@ -90,7 +90,7 @@ module RuboCop
       # This method depends on the fact that we have guarded
       # against implicit and empty literals.
       def opening_brace_on_same_line?(node)
-        node.loc.begin.line == children(node).first.first_line
+        same_line?(node.loc.begin, children(node).first)
       end
 
       # This method depends on the fact that we have guarded

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

@@ -35,7 +35,15 @@ module RuboCop
           previous: gem_name(current),
           current: gem_name(previous)
         )
-        add_offense(current, message: message)
+
+        add_offense(current, message: message) do |corrector|
+          OrderedGemCorrector.correct(
+            processed_source,
+            current,
+            previous_declaration(current),
+            treat_comments_as_separators
+          ).call(corrector)
+        end
       end
 
       def gem_name(declaration_node)

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

@@ -36,10 +36,18 @@ module RuboCop
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
 
-        return unless style == :brackets || invalid_percent_array_contents?(node)
+        brackets_required = invalid_percent_array_contents?(node)
+        return unless style == :brackets || brackets_required
 
-        add_offense(node, message: self.class::ARRAY_MSG) do |corrector|
-          correct_bracketed(corrector, node)
+        # If in percent style but brackets are required due to
+        # string content, the file should be excluded in auto-gen-config
+        no_acceptable_style! if brackets_required
+
+        bracketed_array = build_bracketed_array(node)
+        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
+
+        add_offense(node, message: message) do |corrector|
+          corrector.replace(node, bracketed_array)
         end
       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/space_after_punctuation.rb

@@ -28,7 +28,7 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.column == token1.column + offset
+        same_line?(token1, token2) && token2.column == token1.column + offset
       end
 
       def space_required_before?(token)

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

@@ -32,7 +32,7 @@ module RuboCop
       end
 
       def space_missing?(token1, token2)
-        token1.line == token2.line && token2.begin_pos > token1.end_pos
+        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)

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

@@ -54,7 +54,7 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment
 
         comment_source = comment.loc.expression.source

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

@@ -10,7 +10,7 @@ module RuboCop
       end
 
       def body_on_first_line?(node, body)
-        node.source_range.first_line == body.source_range.first_line
+        same_line?(node, body)
       end
 
       def first_part_of(body)

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

@@ -24,7 +24,7 @@ module RuboCop
       #   # With `AllowNamesEndingInNumbers` set to false
       #   foo { |num1, num2| num1 * num2 }
       #
-      #   # With `MinParamNameLength` set to number greater than 1
+      #   # With `MinNameLength` set to number greater than 1
       #   baz { |a, b, c| do_stuff(a, b, c) }
       #
       #   # good

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

@@ -14,6 +14,18 @@ module RuboCop
       # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
       # gemspec is supposed to be named `bundler-console.gemspec`.
       #
+      # When `ExpectMatchingDefinition` (default: `false`) is `true`, the cop requires
+      # each file to have a class, module or `Struct` defined in it that matches
+      # the filename. This can be further configured using
+      # `CheckDefinitionPathHierarchy` (default: `true`) to determine whether the
+      # path should match the namespace of the above definition.
+      #
+      # When `IgnoreExecutableScripts` (default: `true`) is `true`, files that start
+      # with a shebang line are not considered by the cop.
+      #
+      # When `Regex` is set, the cop will flag any filename that does not match
+      # the regular expression.
+      #
       # @example
       #   # bad
       #   lib/layoutManager.rb
@@ -28,11 +40,19 @@ module RuboCop
         include RangeHelp
 
         MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) should use snake_case.'
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module called `%<namespace>s`.'
+        MSG_NO_DEFINITION = '`%<basename>s` should define a class or module called `%<namespace>s`.'
         MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
 
         SNAKE_CASE = /^[\d[[:lower:]]_.?!]+$/.freeze
 
+        # @!method struct_definition(node)
+        def_node_matcher :struct_definition, <<~PATTERN
+          {
+            (casgn $_ $_        (send (const {nil? cbase} :Struct) :new ...))
+            (casgn $_ $_ (block (send (const {nil? cbase} :Struct) :new ...) ...))
+          }
+        PATTERN
+
         def on_new_investigation
           file_path = processed_source.file_path
           return if config.file_to_exclude?(file_path) || config.allowed_camel_case_file?(file_path)
@@ -103,6 +123,10 @@ module RuboCop
           cop_config['CheckDefinitionPathHierarchy']
         end
 
+        def definition_path_hierarchy_roots
+          cop_config['CheckDefinitionPathHierarchyRoots'] || []
+        end
+
         def regex
           cop_config['Regex']
         end
@@ -126,7 +150,7 @@ module RuboCop
           name = namespace.pop
 
           on_node(%i[class module casgn], node) do |child|
-            next unless (const = child.defined_module)
+            next unless (const = find_definition(child))
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
@@ -138,6 +162,15 @@ module RuboCop
           nil
         end
 
+        def find_definition(node)
+          node.defined_module || defined_struct(node)
+        end
+
+        def defined_struct(node)
+          namespace, name = *struct_definition(node)
+          s(:const, namespace, name) if name
+        end
+
         def match_namespace(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
@@ -177,13 +210,13 @@ module RuboCop
           allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
         end
 
-        def to_namespace(path)
+        def to_namespace(path) # rubocop:disable Metrics/AbcSize
           components = Pathname(path).each_filename.to_a
           # To convert a pathname to a Ruby namespace, we need a starting point
           # But RC can be run from any working directory, and can check any path
           # We can't assume that the working directory, or any other, is the
           # "starting point" to build a namespace.
-          start = %w[lib spec test src]
+          start = definition_path_hierarchy_roots
           start_index = nil
 
           # To find the closest namespace root take the path components, and

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

@@ -70,6 +70,8 @@ module RuboCop
         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)
 
@@ -197,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)
@@ -223,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)
@@ -235,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/naming/memoized_instance_variable_name.rb

@@ -14,6 +14,11 @@ module RuboCop
       # convention that is used to implicitly indicate that an ivar should not
       # be set or referenced outside of the memoization method.
       #
+      # @safety
+      #   This cop relies on the pattern `@instance_var ||= ...`,
+      #   but this is sometimes used for other purposes than memoization
+      #   so this cop is considered unsafe.
+      #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
       #   # Method foo is memoized using an instance variable that is
@@ -139,10 +144,6 @@ module RuboCop
       #   define_method(:foo) do
       #     @_foo ||= calculate_expensive_thing
       #   end
-      #
-      # This cop relies on the pattern `@instance_var ||= ...`,
-      # but this is sometimes used for other purposes than memoization
-      # so this cop is considered unsafe.
       class MemoizedInstanceVariableName < Base
         include ConfigurableEnforcedStyle
 

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

@@ -75,6 +75,9 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           return if preferred_name.to_sym == offending_name
 
+          # check variable shadowing for exception variable
+          return if shadowed_variable_name?(node)
+
           range = offense_range(node)
           message = message(node)
 
@@ -150,6 +153,10 @@ module RuboCop
           preferred_name = preferred_name(offending_name)
           format(MSG, preferred: preferred_name, bad: offending_name)
         end
+
+        def shadowed_variable_name?(node)
+          node.each_descendant(:lvar).any? { |n| n.children.first.to_s == preferred_name(n) }
+        end
       end
     end
   end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Security
+      # Checks for the first argument to `IO.read`, `IO.binread`, `IO.write`, `IO.binwrite`,
+      # `IO.foreach`, and `IO.readlines`.
+      #
+      # If argument starts with a pipe character (`'|'`) and the receiver is the `IO` class,
+      # a subprocess is created in the same way as `Kernel#open`, and its output is returned.
+      # `Kernel#open` may allow unintentional command injection, which is the reason these
+      # `IO` methods are a security risk.
+      # Consider to use `File.read` to disable the behavior of subprocess invocation.
+      #
+      # @safety
+      #   This cop is unsafe because false positive will occur if the variable passed as
+      #   the first argument is a command that is not a file path.
+      #
+      # @example
+      #
+      #   # bad
+      #   IO.read(path)
+      #   IO.read('path')
+      #
+      #   # good
+      #   File.read(path)
+      #   File.read('path')
+      #   IO.read('| command') # Allow intentional command invocation.
+      #
+      class IoMethods < Base
+        extend AutoCorrector
+
+        MSG = '`File.%<method_name>s` is safer than `IO.%<method_name>s`.'
+        RESTRICT_ON_SEND = %i[read binread write binwrite foreach readlines].freeze
+
+        def on_send(node)
+          return unless (receiver = node.receiver) && receiver.source == 'IO'
+
+          argument = node.first_argument
+          return if argument.respond_to?(:value) && argument.value.strip.start_with?('|')
+
+          add_offense(node, message: format(MSG, method_name: node.method_name)) do |corrector|
+            corrector.replace(receiver, 'File')
+          end
+        end
+      end
+    end
+  end
+end