Class: SyntaxTree::CallChainFormatter

Inherits:

Object

• Object
• SyntaxTree::CallChainFormatter

Defined in:

lib/syntax_tree/node.rb

Overview

This is probably the most complicated formatter in this file. It’s responsible for formatting chains of method calls, with or without arguments or blocks. In general, we want to go from something like

foo.bar.baz

to

foo
  .bar
  .baz

Of course there are a lot of caveats to that, including trailing operators when necessary, where comments are places, how blocks are aligned, etc.

Instance Attribute Summary

• #node ⇒ Object readonly

  Call | MethodAddBlock

  the top of the call chain.

Class Method Summary

• .chained?(node) ⇒ Boolean

Instance Method Summary

• #format(q) ⇒ Object
• #format_chain(q, children) ⇒ Object
• #initialize(node) ⇒ CallChainFormatter constructor

  A new instance of CallChainFormatter.

Constructor Details

#initialize(node) ⇒ CallChainFormatter

Returns a new instance of CallChainFormatter.

# File 'lib/syntax_tree/node.rb', line 2344

def initialize(node)
  @node = node
end

Instance Attribute Details

#node ⇒ Object (readonly)

Call | MethodAddBlock

the top of the call chain

# File 'lib/syntax_tree/node.rb', line 2342

def node
  @node
end

Class Method Details

.chained?(node) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/syntax_tree/node.rb', line 2477

def self.chained?(node)
  case node
  in Call | MethodAddBlock[call: Call]
    true
  else
    false
  end
end

Instance Method Details

#format(q) ⇒ Object

# File 'lib/syntax_tree/node.rb', line 2348

def format(q)
  children = [node]
  threshold = 3

  # First, walk down the chain until we get to the point where we're not
  # longer at a chainable node.
  loop do
    case children.last
    in Call[receiver: Call]
      children << children.last.receiver
    in Call[receiver: MethodAddBlock[call: Call]]
      children << children.last.receiver
    in MethodAddBlock[call: Call]
      children << children.last.call
    else
      break
    end
  end

  # Here, we have very specialized behavior where if we're within a sig
  # block, then we're going to assume we're creating a Sorbet type
  # signature. In that case, we really want the threshold to be lowered so
  # that we create method chains off of any two method calls within the
  # block. For more details, see
  # https://github.com/prettier/plugin-ruby/issues/863.
  parents = q.parents.take(4)
  if (parent = parents[2])
    # If we're at a do_block, then we want to go one more level up. This is
    # because do blocks have BodyStmt nodes instead of just Statements
    # nodes.
    parent = parents[3] if parent.is_a?(DoBlock)

    case parent
    in MethodAddBlock[call: FCall[value: { value: "sig" }]]
      threshold = 2
    else
    end
  end

  if children.length >= threshold
    q.group do
      q
        .if_break { format_chain(q, children) }
        .if_flat { node.format_contents(q) }
    end
  else
    node.format_contents(q)
  end
end

#format_chain(q, children) ⇒ Object

# File 'lib/syntax_tree/node.rb', line 2398

def format_chain(q, children)
  # We're going to have some specialized behavior for if it's an entire
  # chain of calls without arguments except for the last one. This is common
  # enough in Ruby source code that it's worth the extra complexity here.
  empty_except_last =
    children
      .drop(1)
      .all? { |child| child.is_a?(Call) && child.arguments.nil? }

  # Here, we're going to add all of the children onto the stack of the
  # formatter so it's as if we had descending normally into them. This is
  # necessary so they can check their parents as normal.
  q.stack.concat(children)
  q.format(children.last.receiver)

  q.group do
    if attach_directly?(children.last)
      format_child(q, children.pop)
      q.stack.pop
    end

    q.indent do
      # We track another variable that checks if you need to move the
      # operator to the previous line in case there are trailing comments
      # and a trailing operator.
      skip_operator = false

      while (child = children.pop)
        case child
        in Call[
             receiver: Call[message: { value: "where" }],
             message: { value: "not" }
           ]
          # This is very specialized behavior wherein we group
          # .where.not calls together because it looks better. For more
          # information, see
          # https://github.com/prettier/plugin-ruby/issues/862.
        in Call
          # If we're at a Call node and not a MethodAddBlock node in the
          # chain then we're going to add a newline so it indents properly.
          q.breakable("")
        else
        end

        format_child(
          q,
          child,
          skip_comments: children.empty?,
          skip_operator: skip_operator,
          skip_attached: empty_except_last && children.empty?
        )

        # If the parent call node has a comment on the message then we need
        # to print the operator trailing in order to keep it working.
        case children.last
        in Call[message: { comments: [_, *] }, operator:]
          q.format(CallOperatorFormatter.new(operator))
          skip_operator = true
        else
          skip_operator = false
        end

        # Pop off the formatter's stack so that it aligns with what would
        # have happened if we had been formatting normally.
        q.stack.pop
      end
    end
  end

  if empty_except_last
    case node
    in Call
      node.format_arguments(q)
    in MethodAddBlock[block:]
      q.format(block)
    end
  end
end