Class: SyntaxTree::FlowControlFormatter

Inherits:

Object

• Object
• SyntaxTree::FlowControlFormatter

Defined in:

lib/syntax_tree/node.rb

Overview

Formats either a Break, Next, or Return node.

Instance Attribute Summary

• #keyword ⇒ Object readonly

  String

  the keyword to print.

• #node ⇒ Object readonly

  Break | Next | Return

  the node being formatted.

Instance Method Summary

• #format(q) ⇒ Object
• #initialize(keyword, node) ⇒ FlowControlFormatter constructor

  A new instance of FlowControlFormatter.

Constructor Details

#initialize(keyword, node) ⇒ FlowControlFormatter

Returns a new instance of FlowControlFormatter.

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

def initialize(keyword, node)
  @keyword = keyword
  @node = node
end

Instance Attribute Details

#keyword ⇒ Object (readonly)

String

the keyword to print

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

def keyword
  @keyword
end

#node ⇒ Object (readonly)

Break | Next | Return

the node being formatted

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

def node
  @node
end

Instance Method Details

#format(q) ⇒ Object

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

def format(q)
  q.group do
    q.text(keyword)

    case node.arguments.parts
    in []
      # Here there are no arguments at all, so we're not going to print
      # anything. This would be like if we had:
      #
      #     break
      #
    in [
         Paren[
           contents: {
             body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
           }
         ]
       ]
      # Here we have a single argument that is a set of parentheses wrapping
      # an array literal that has at least 2 elements. We're going to print
      # the contents of the array directly. This would be like if we had:
      #
      #     break([1, 2, 3])
      #
      # which we will print as:
      #
      #     break 1, 2, 3
      #
      q.text(" ")
      format_array_contents(q, array)
    in [Paren[contents: { body: [ArrayLiteral => statement] }]]
      # Here we have a single argument that is a set of parentheses wrapping
      # an array literal that has 0 or 1 elements. We're going to skip the
      # parentheses but print the array itself. This would be like if we
      # had:
      #
      #     break([1])
      #
      # which we will print as:
      #
      #     break [1]
      #
      q.text(" ")
      q.format(statement)
    in [Paren[contents: { body: [statement] }]] if skip_parens?(statement)
      # Here we have a single argument that is a set of parentheses that
      # themselves contain a single statement. That statement is a simple
      # value that we can skip the parentheses for. This would be like if we
      # had:
      #
      #     break(1)
      #
      # which we will print as:
      #
      #     break 1
      #
      q.text(" ")
      q.format(statement)
    in [Paren => part]
      # Here we have a single argument that is a set of parentheses. We're
      # going to print the parentheses themselves as if they were the set of
      # arguments. This would be like if we had:
      #
      #     break(foo.bar)
      #
      q.format(part)
    in [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
      # Here there is a single argument that is an array literal with at
      # least two elements. We skip directly into the array literal's
      # elements in order to print the contents. This would be like if we
      # had:
      #
      #     break [1, 2, 3]
      #
      # which we will print as:
      #
      #     break 1, 2, 3
      #
      q.text(" ")
      format_array_contents(q, array)
    in [ArrayLiteral => part]
      # Here there is a single argument that is an array literal with 0 or 1
      # elements. In this case we're going to print the array as it is
      # because skipping the brackets would change the remaining. This would
      # be like if we had:
      #
      #     break []
      #     break [1]
      #
      q.text(" ")
      q.format(part)
    in [_]
      # Here there is a single argument that hasn't matched one of our
      # previous cases. We're going to print the argument as it is. This
      # would be like if we had:
      #
      #     break foo
      #
      format_arguments(q, "(", ")")
    else
      # If there are multiple arguments, format them all. If the line is
      # going to break into multiple, then use brackets to start and end the
      # expression.
      format_arguments(q, " [", "]")
    end
  end
end