rubocop 0.78.0

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking integer nodes.
+    module IntegerNode
+      private
+
+      def integer_part(node)
+        node.source.sub(/^[+-]/, '').split(/[eE.]/, 2).first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      end
+
+      def directive_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment =
+          processed_source.comments
+                          .detect { |e| e.location.line == source_line_number }
+
+        return false unless comment
+
+        comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+      end
+
+      def allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      end
+
+      def find_excessive_uri_range(line)
+        last_uri_match = match_uris(line).last
+        return nil unless last_uri_match
+
+        begin_position, end_position = last_uri_match.offset(0).map do |pos|
+          pos + indentation_difference(line)
+        end
+        return nil if begin_position < max_line_length &&
+                      end_position < max_line_length
+
+        begin_position...end_position
+      end
+
+      def match_uris(string)
+        matches = []
+        string.scan(uri_regexp) do
+          matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+        end
+        matches
+      end
+
+      def indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/Tab')['IndentationWidth']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for obtaining source ranges from regexp matches
+    module MatchRange
+      include RangeHelp
+
+      private
+
+      # Return a new `Range` covering the first matching group number for each
+      # match of `regex` inside `range`
+      def each_match_range(range, regex)
+        range.source.scan(regex) do
+          yield match_range(range, Regexp.last_match)
+        end
+      end
+
+      # For a `match` inside `range`, return a new `Range` covering the match
+      def match_range(range, match)
+        range_between(range.begin_pos + match.begin(1),
+                      range.begin_pos + match.end(1))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module handles measurement and reporting of complexity in methods.
+    module MethodComplexity
+      include ConfigurableMax
+      extend NodePattern::Macros
+
+      def on_def(node)
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          check_complexity(node, name)
+        end
+      end
+
+      private
+
+      def_node_matcher :define_method?, <<~PATTERN
+        (block
+         (send nil? :define_method ({sym str} $_))
+         args
+         _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
+        max = cop_config['Max']
+        complexity, abc_vector = complexity(node.body)
+
+        return unless complexity > max
+
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     abc_vector: abc_vector,
+                     max: max)
+
+        add_offense(node, message: msg) do
+          self.max = complexity.ceil
+        end
+      end
+
+      def complexity(body)
+        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+          score + complexity_score_for(n)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for cops that deal with preferred methods.
+    module MethodPreference
+      private
+
+      def preferred_method(method)
+        preferred_methods[method.to_sym]
+      end
+
+      def preferred_methods
+        @preferred_methods ||=
+          begin
+            # Make sure default configuration 'foo' => 'bar' is removed from
+            # the total configuration if there is a 'bar' => 'foo' override.
+            default = default_cop_config['PreferredMethods']
+            merged = cop_config['PreferredMethods']
+            overrides = merged.values - default.values
+            merged.reject { |key, _| overrides.include?(key) }
+                  .map { |k, v| [k.to_sym, v] }.to_h
+          end
+      end
+
+      def default_cop_config
+        ConfigLoader.default_configuration[cop_name]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum body length.
+    module MinBodyLength
+      private
+
+      def min_body_length?(node)
+        (node.loc.end.line - node.loc.keyword.line) > min_body_length
+      end
+
+      def min_body_length
+        length = cop_config['MinBodyLength'] || 1
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBodyLength needs to be a positive integer!'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common code for indenting the first elements in multiline
+    # array literals, hash literals, and method definitions.
+    module MultilineElementIndentation
+      private
+
+      def each_argument_node(node, type)
+        left_parenthesis = node.loc.begin
+
+        return unless left_parenthesis
+
+        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
+              yield type_node, left_parenthesis
+              ignore_node(type_node)
+            end
+          end
+        end
+      end
+
+      def check_first(first, left_brace, left_parenthesis, offset)
+        actual_column = first.source_range.column
+        expected_column = base_column(left_brace, left_parenthesis) +
+                          configured_indentation_width + offset
+        @column_delta = expected_column - actual_column
+        styles =
+          detected_styles(actual_column, offset, left_parenthesis, left_brace)
+
+        if @column_delta.zero?
+          check_expected_style(styles)
+        else
+          incorrect_style_detected(styles, first, left_parenthesis)
+        end
+      end
+
+      def check_expected_style(styles)
+        if styles.size > 1
+          ambiguous_style_detected(*styles)
+        else
+          correct_style_detected
+        end
+      end
+
+      def base_column(left_brace, left_parenthesis)
+        if style == brace_alignment_style
+          left_brace.column
+        elsif left_parenthesis && style == :special_inside_parentheses
+          left_parenthesis.column + 1
+        else
+          left_brace.source_line =~ /\S/
+        end
+      end
+
+      def detected_styles(actual_column, offset, left_parenthesis, left_brace)
+        base_column = actual_column - configured_indentation_width - offset
+        detected_styles_for_column(base_column, left_parenthesis, left_brace)
+      end
+
+      def detected_styles_for_column(column, left_parenthesis, left_brace)
+        styles = []
+        if column == (left_brace.source_line =~ /\S/)
+          styles << :consistent
+          styles << :special_inside_parentheses unless left_parenthesis
+        end
+        if left_parenthesis && column == left_parenthesis.column + 1
+          styles << :special_inside_parentheses
+        end
+        styles << brace_alignment_style if column == left_brace.column
+        styles
+      end
+
+      def incorrect_style_detected(styles, first, left_parenthesis)
+        msg = message(base_description(left_parenthesis))
+
+        add_offense(first, message: msg) do
+          ambiguous_style_detected(*styles)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# TEAM: backend_infra
+# WATCHERS: maxh
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for a line break before each
+    # element in a multi-line collection.
+    module MultilineElementLineBreaks
+      private
+
+      def check_line_breaks(_node, children)
+        return if all_on_same_line?(children)
+
+        last_seen_line = -1
+        children.each do |child|
+          if last_seen_line >= child.first_line
+            add_offense(child)
+          else
+            last_seen_line = child.last_line
+          end
+        end
+      end
+
+      def all_on_same_line?(nodes)
+        return true if nodes.empty?
+
+        nodes.first.first_line == nodes.last.last_line
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking multiline method calls and binary
+    # operations.
+    module MultilineExpressionIndentation # rubocop:disable Metrics/ModuleLength
+      KEYWORD_ANCESTOR_TYPES  = %i[for if while until return].freeze
+      UNALIGNED_RHS_TYPES     = %i[if while until for return
+                                   array kwbegin].freeze
+      DEFAULT_MESSAGE_TAIL    = 'an expression'
+      ASSIGNMENT_MESSAGE_TAIL = 'an expression in an assignment'
+      KEYWORD_MESSAGE_TAIL    = 'a %<kind>s in %<article>s `%<keyword>s` ' \
+                                'statement'
+
+      def on_send(node)
+        return if !node.receiver || node.method?(:[])
+        return unless relevant_node?(node)
+
+        lhs = left_hand_side(node.receiver)
+        rhs = right_hand_side(node)
+        range = offending_range(node, lhs, rhs, style)
+        check(range, node, lhs, rhs)
+      end
+
+      private
+
+      # In a chain of method calls, we regard the top send node as the base
+      # for indentation of all lines following the first. For example:
+      # a.
+      #   b c { block }.            <-- b is indented relative to a
+      #   d                         <-- d is indented relative to a
+      def left_hand_side(lhs)
+        lhs = lhs.parent while lhs.parent&.send_type?
+        lhs
+      end
+
+      def right_hand_side(send_node)
+        if send_node.operator_method? && send_node.arguments?
+          send_node.first_argument.source_range # not used for method calls
+        else
+          regular_method_right_hand_side(send_node)
+        end
+      end
+
+      def regular_method_right_hand_side(send_node)
+        dot = send_node.loc.dot
+        selector = send_node.loc.selector
+        if send_node.dot? && selector && dot.line == selector.line
+          dot.join(selector)
+        elsif selector
+          selector
+        elsif send_node.implicit_call?
+          dot.join(send_node.loc.begin)
+        end
+      end
+
+      # The correct indentation of `node` is usually `IndentationWidth`, with
+      # one exception: prefix keywords.
+      #
+      # ```
+      # while foo &&  # Here, `while` is called a "prefix keyword"
+      #     bar       # This is called "special indentation"
+      #   baz
+      # end
+      # ```
+      #
+      # Note that *postfix conditionals* do *not* get "special indentation".
+      #
+      # ```
+      # next if foo &&
+      #   bar # normal indentation, not special
+      # ```
+      def correct_indentation(node)
+        kw_node = kw_node_with_special_indentation(node)
+        if kw_node && !postfix_conditional?(kw_node)
+          # This cop could have its own IndentationWidth configuration
+          configured_indentation_width +
+            @config.for_cop('Layout/IndentationWidth')['Width']
+        else
+          configured_indentation_width
+        end
+      end
+
+      def check(range, node, lhs, rhs)
+        if range
+          incorrect_style_detected(range, node, lhs, rhs)
+        else
+          correct_style_detected
+        end
+      end
+
+      def incorrect_style_detected(range, node, lhs, rhs)
+        add_offense(range, location: range, message: message(node, lhs, rhs)) do
+          if supported_styles.size > 2 ||
+             offending_range(node, lhs, rhs, alternative_style)
+            unrecognized_style_detected
+          else
+            opposite_style_detected
+          end
+        end
+      end
+
+      def indentation(node)
+        node.source_range.source_line =~ /\S/
+      end
+
+      def operation_description(node, rhs)
+        kw_node_with_special_indentation(node) do |ancestor|
+          return keyword_message_tail(ancestor)
+        end
+
+        part_of_assignment_rhs(node, rhs) do |_node|
+          return ASSIGNMENT_MESSAGE_TAIL
+        end
+
+        DEFAULT_MESSAGE_TAIL
+      end
+
+      def keyword_message_tail(node)
+        keyword = node.loc.keyword.source
+        kind    = keyword == 'for' ? 'collection' : 'condition'
+        article = keyword.start_with?('i', 'u') ? 'an' : 'a'
+
+        format(KEYWORD_MESSAGE_TAIL, kind: kind,
+                                     article: article,
+                                     keyword: keyword)
+      end
+
+      def kw_node_with_special_indentation(node)
+        keyword_node =
+          node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
+            next if ancestor.if_type? && ancestor.ternary?
+
+            within_node?(node, indented_keyword_expression(ancestor))
+          end
+
+        if keyword_node && block_given?
+          yield keyword_node
+        else
+          keyword_node
+        end
+      end
+
+      def indented_keyword_expression(node)
+        if node.for_type?
+          expression = node.collection
+        else
+          expression, = *node
+        end
+
+        expression
+      end
+
+      def argument_in_method_call(node, kind)
+        node.each_ancestor(:send, :block).find do |a|
+          # If the node is inside a block, it makes no difference if that block
+          # is an argument in a method call. It doesn't count.
+          break false if a.block_type?
+
+          next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      kind == :with_parentheses && parentheses?(a)
+
+          a.arguments.any? do |arg|
+            within_node?(node, arg)
+          end
+        end
+      end
+
+      def part_of_assignment_rhs(node, candidate)
+        rhs_node = node.each_ancestor.find do |ancestor|
+          break if disqualified_rhs?(candidate, ancestor)
+
+          valid_rhs?(candidate, ancestor)
+        end
+
+        if rhs_node && block_given?
+          yield rhs_node
+        else
+          rhs_node
+        end
+      end
+
+      def disqualified_rhs?(candidate, ancestor)
+        UNALIGNED_RHS_TYPES.include?(ancestor.type) ||
+          ancestor.block_type? && part_of_block_body?(candidate, ancestor)
+      end
+
+      def valid_rhs?(candidate, ancestor)
+        if ancestor.send_type?
+          valid_method_rhs_candidate?(candidate, ancestor)
+        elsif ancestor.assignment?
+          valid_rhs_candidate?(candidate, assignment_rhs(ancestor))
+        else
+          false
+        end
+      end
+
+      # The []= operator and setters (a.b = c) are parsed as :send nodes.
+      def valid_method_rhs_candidate?(candidate, node)
+        node.setter_method? &&
+          valid_rhs_candidate?(candidate, node.last_argument)
+      end
+
+      def valid_rhs_candidate?(candidate, node)
+        !candidate || within_node?(candidate, node)
+      end
+
+      def part_of_block_body?(candidate, block_node)
+        block_node.body && within_node?(candidate, block_node.body)
+      end
+
+      def assignment_rhs(node)
+        case node.type
+        when :casgn   then _scope, _lhs, rhs = *node
+        when :op_asgn then _lhs, _op, rhs = *node
+        when :send    then rhs = node.last_argument
+        else               _lhs, rhs = *node
+        end
+        rhs
+      end
+
+      def not_for_this_cop?(node)
+        node.ancestors.any? do |ancestor|
+          grouped_expression?(ancestor) ||
+            inside_arg_list_parentheses?(node, ancestor)
+        end
+      end
+
+      def grouped_expression?(node)
+        node.begin_type? && node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def inside_arg_list_parentheses?(node, ancestor)
+        return false unless ancestor.send_type? && ancestor.parenthesized?
+
+        node.source_range.begin_pos > ancestor.loc.begin.begin_pos &&
+          node.source_range.end_pos < ancestor.loc.end.end_pos
+      end
+
+      # Returns true if `node` is a conditional whose `body` and `condition`
+      # begin on the same line.
+      def postfix_conditional?(node)
+        node.if_type? && node.modifier_form?
+      end
+
+      def within_node?(inner, outer)
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      end
+    end
+  end
+end