rubocop 0.87.1

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) # rubocop:todo Metrics/CyclomaticComplexity
+        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

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking the closing brace of a literal is
+    # either on the same line as the last contained elements or a new line.
+    module MultilineLiteralBraceLayout
+      include ConfigurableEnforcedStyle
+
+      private
+
+      def check_brace_layout(node)
+        return if ignored_literal?(node)
+
+        # If the last node is or contains a conflicting HEREDOC, we don't want
+        # to adjust the brace layout because this will result in invalid code.
+        return if last_line_heredoc?(node.children.last)
+
+        check(node)
+      end
+
+      # Returns true for the case
+      #   [a,
+      #    b # comment
+      #   ].some_method
+      def new_line_needed_before_closing_brace?(node)
+        last_element_line =
+          last_element_range_with_trailing_comma(node).last_line
+
+        last_element_commented =
+          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented && (node.chained? || node.argument?)
+      end
+
+      def check(node)
+        case style
+        when :symmetrical then check_symmetrical(node)
+        when :new_line then check_new_line(node)
+        when :same_line then check_same_line(node)
+        end
+      end
+
+      def check_new_line(node)
+        return unless closing_brace_on_same_line?(node)
+
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_NEW_LINE_MESSAGE)
+      end
+
+      def check_same_line(node)
+        return if closing_brace_on_same_line?(node)
+
+        add_offense(node,
+                    location: :end,
+                    message: self.class::ALWAYS_SAME_LINE_MESSAGE)
+      end
+
+      def check_symmetrical(node)
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, location: :end,
+                            message: self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, location: :end,
+                            message: self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
+      def empty_literal?(node)
+        children(node).empty?
+      end
+
+      def implicit_literal?(node)
+        !node.loc.begin
+      end
+
+      def ignored_literal?(node)
+        implicit_literal?(node) || empty_literal?(node) || node.single_line?
+      end
+
+      def children(node)
+        node.children
+      end
+
+      # 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
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.last_line
+      end
+
+      # Starting with the parent node and recursively for the parent node's
+      # children, check if the node is a HEREDOC and if the HEREDOC ends below
+      # or on the last line of the parent node.
+      #
+      # Example:
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => false
+      #   foo(a,
+      #     b: {
+      #       a: 1,
+      #       c: <<-EOM
+      #         baz
+      #       EOM
+      #     }
+      #   )
+      #
+      #   # node is `b: ...` parameter
+      #   # last_line_heredoc?(node) => true
+      #   foo(a,
+      #     b: <<-EOM
+      #       baz
+      #     EOM
+      #   )
+      def last_line_heredoc?(node, parent = nil)
+        parent ||= node
+
+        if node.respond_to?(:loc) &&
+           node.loc.respond_to?(:heredoc_end) &&
+           node.loc.heredoc_end.last_line >= parent.last_line
+          return true
+        end
+
+        return false unless node.respond_to?(:children)
+
+        node.children.any? { |child| last_line_heredoc?(child, parent) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
+    module NegativeConditional
+      extend NodePattern::Macros
+
+      MSG = 'Favor `%<inverse>s` over `%<current>s` for ' \
+            'negative conditions.'
+
+      private
+
+      def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
+      def_node_matcher :empty_condition?, '(begin)'
+
+      def check_negative_conditional(node)
+        condition = node.condition
+
+        return if empty_condition?(condition)
+
+        condition = condition.children.last while condition.begin_type?
+
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
+
+        add_offense(node)
+      end
+    end
+  end
+end