rubocop 0.73.0 → 0.74.0

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

@@ -9,8 +9,6 @@ module RuboCop
 
       private
 
-      def_node_matcher :constant_definition?, '{class module casgn}'
-
       def documentation_comment?(node)
         preceding_lines = preceding_lines(node)
 

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -19,6 +19,18 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
+      def aligned_with_preceding_assignment(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_assignment(token, preceding_line_range)
+      end
+
+      def aligned_with_subsequent_assignment(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_assignment(token, subsequent_line_range)
+      end
+
       def aligned_with_adjacent_line?(range, predicate)
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
@@ -89,6 +101,81 @@ module RuboCop
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
+
+      def aligned_with_assignment(token, line_range)
+        token_line_indent    = processed_source
+                               .line_indentation(token.line)
+        assignment_lines     = relevant_assignment_lines(line_range)
+        relevant_line_number = assignment_lines[1]
+
+        return :none unless relevant_line_number
+
+        relevant_indent = processed_source
+                          .line_indentation(relevant_line_number)
+
+        return :none if relevant_indent < token_line_indent
+
+        assignment_line = processed_source.lines[relevant_line_number - 1]
+
+        return :none unless assignment_line
+
+        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+      end
+
+      def assignment_lines
+        @assignment_lines ||= assignment_tokens.map(&:line)
+      end
+
+      def assignment_tokens
+        @assignment_tokens ||= begin
+          tokens = processed_source.tokens.select(&:equal_sign?)
+
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+      def relevant_assignment_lines(line_range)
+        result                        = []
+        original_line_indent          = processed_source
+                                        .line_indentation(line_range.first)
+        relevant_line_indent_at_level = true
+
+        line_range.each do |line_number|
+          current_line_indent = processed_source.line_indentation(line_number)
+          blank_line          = processed_source.lines[line_number - 1].blank?
+
+          if (current_line_indent < original_line_indent && !blank_line) ||
+             (relevant_line_indent_at_level && blank_line)
+            break
+          end
+
+          result << line_number if assignment_lines.include?(line_number) &&
+                                   current_line_indent == original_line_indent
+
+          unless blank_line
+            relevant_line_indent_at_level = \
+              current_line_indent == original_line_indent
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+
+      def remove_optarg_equals(asgn_tokens, processed_source)
+        optargs    = processed_source.ast.each_node(:optarg)
+        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      end
     end
   end
 end

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

@@ -9,6 +9,8 @@ module RuboCop
       NO_SPACE_COMMAND = 'Do not use'
       SPACE_COMMAND = 'Use'
 
+      SINGLE_SPACE_REGEXP = /[ \t]/.freeze
+
       private
 
       def side_space_range(range:, side:)
@@ -18,11 +20,11 @@ module RuboCop
         begin_pos = range.begin_pos
         end_pos = range.end_pos
         if side == :left
+          end_pos = begin_pos
           begin_pos = reposition(src, begin_pos, -1)
-          end_pos -= 1
         end
         if side == :right
-          begin_pos += 1
+          begin_pos = end_pos
           end_pos = reposition(src, end_pos, 1)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
@@ -85,15 +87,15 @@ module RuboCop
         return false unless token
 
         if side == :left
-          String(token.space_after?) == ' '
+          String(token.space_after?) =~ SINGLE_SPACE_REGEXP
         else
-          String(token.space_before?) == ' '
+          String(token.space_before?) =~ SINGLE_SPACE_REGEXP
         end
       end
 
       def reposition(src, pos, step)
         offset = step == -1 ? -1 : 0
-        pos += step while src[pos + offset] =~ /[ \t]/
+        pos += step while src[pos + offset] =~ SINGLE_SPACE_REGEXP
         pos.negative? ? 0 : pos
       end
 

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

@@ -33,26 +33,12 @@ 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
 
@@ -61,25 +47,19 @@ module RuboCop
         KEYWORDS = %w[begin class def end module].freeze
         ALLOWED_COMMENTS = %w[:nodoc: :yields: rubocop:disable].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,7 +68,7 @@ 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
 
@@ -219,8 +219,6 @@ 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

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

@@ -46,7 +46,14 @@ module RuboCop
         end
 
         def class_or_module_scope?(node)
-          node.parent && %i[class module].include?(node.parent.type)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
         end
 
         def visibility_declaration?(node)
@@ -58,8 +65,12 @@ module RuboCop
         end
 
         def_node_matcher :visibility_declaration_for?, <<~PATTERN
-          (send nil? {:public_constant :private_constant} ({sym str} %1))
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
         PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
       end
     end
   end

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

@@ -37,9 +37,10 @@ module RuboCop
       #   ok
       class GuardClause < Cop
         include MinBodyLength
+        include StatementModifier
 
-        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
-              'conditional expression.'
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
 
         def on_def(node)
           body = node.body
@@ -55,9 +56,19 @@ module RuboCop
         alias on_defs on_def
 
         def on_if(node)
-          return if accepted_form?(node) || !contains_guard_clause?(node)
+          return if accepted_form?(node)
 
-          add_offense(node, location: :keyword)
+          guard_clause_in_if = node.if_branch&.guard_clause?
+          guard_clause_in_else = node.else_branch&.guard_clause?
+          guard_clause = guard_clause_in_if || guard_clause_in_else
+          return unless guard_clause
+
+          kw = if guard_clause_in_if
+                 node.loc.keyword.source
+               else
+                 opposite_keyword(node)
+               end
+          register_offense(node, guard_clause.source, kw)
         end
 
         private
@@ -65,7 +76,30 @@ module RuboCop
         def check_ending_if(node)
           return if accepted_form?(node, true) || !min_body_length?(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node, 'return', opposite_keyword(node))
+        end
+
+        def opposite_keyword(node)
+          node.if? ? 'unless' : 'if'
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+          condition, = node.node_parts
+          example = [scope_exiting_keyword,
+                     conditional_keyword,
+                     condition.source].join(' ')
+          if too_long_for_single_line?(node, example)
+            example = "#{conditional_keyword} #{condition.source}; " \
+                      "#{scope_exiting_keyword}; end"
+          end
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, example: example))
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
         end
 
         def accepted_form?(node, ending = false)
@@ -81,11 +115,6 @@ module RuboCop
             !node.else? || node.elsif?
           end
         end
-
-        def contains_guard_clause?(node)
-          node.if_branch&.guard_clause? ||
-            node.else_branch&.guard_clause?
-        end
       end
     end
   end

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

@@ -62,8 +62,6 @@ module RuboCop
           }
         }.freeze
 
-        def_node_matcher :lambda_node?, '(block $(send nil? :lambda) ...)'
-
         def on_block(node)
           return unless node.lambda?
 

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

@@ -42,7 +42,7 @@ module RuboCop
         def on_def(node)
           return unless trailing_end?(node)
 
-          add_offense(node.to_a.last, location: end_token(node).pos)
+          add_offense(node, location: end_token(node).pos)
         end
 
         def autocorrect(node)
@@ -61,7 +61,7 @@ module RuboCop
         end
 
         def end_token(node)
-          @end_token ||= tokens(node).reverse.find(&:end?)
+          tokens(node).reverse.find(&:end?)
         end
 
         def body_and_end_on_same_line?(node)
@@ -69,10 +69,8 @@ module RuboCop
         end
 
         def token_before_end(node)
-          @token_before_end ||= begin
-            i = tokens(node).index(end_token(node))
-            tokens(node)[i - 1]
-          end
+          i = tokens(node).index(end_token(node))
+          tokens(node)[i - 1]
         end
 
         def break_line_before_end(node, corrector)

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

@@ -16,19 +16,15 @@ module RuboCop
       #   /check #{$pattern}/
       #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
+        include Interpolation
+
         MSG = 'Replace interpolated variable `%<variable>s` ' \
               'with expression `#{%<variable>s}`.'
 
-        def on_dstr(node)
-          check_for_interpolation(node)
-        end
-
-        def on_regexp(node)
-          check_for_interpolation(node)
-        end
-
-        def on_xstr(node)
-          check_for_interpolation(node)
+        def on_node_with_interpolations(node)
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
+          end
         end
 
         def autocorrect(node)
@@ -39,12 +35,6 @@ module RuboCop
 
         private
 
-        def check_for_interpolation(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node)
-          end
-        end
-
         def message(node)
           format(MSG, variable: node.source)
         end

data/lib/rubocop/path_util.rb

@@ -51,7 +51,7 @@ module RuboCop
 
     # Returns true for an absolute Unix or Windows path.
     def absolute?(path)
-      path =~ %r{\A([A-Z]:)?/}
+      path =~ %r{\A([A-Z]:)?/}i
     end
 
     def self.pwd