Class: SyntaxTree::LoopFormatter

Inherits:
Object
  • Object
show all
Defined in:
lib/syntax_tree/node.rb

Overview

Formats an Until or While node.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(keyword, node) ⇒ LoopFormatter

Returns a new instance of LoopFormatter.



11401
11402
11403
11404
 
# File 'lib/syntax_tree/node.rb', line 11401

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

Instance Attribute Details

#keyword ⇒ Object (readonly)

String

the name of the keyword used for this loop



11396
11397
11398
 
# File 'lib/syntax_tree/node.rb', line 11396

def keyword
  @keyword
end

#node ⇒ Object (readonly)

Until | While

the node that is being formatted



11399
11400
11401
 
# File 'lib/syntax_tree/node.rb', line 11399

def node
  @node
end

Instance Method Details

#format(q) ⇒ Object 



11406
11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
 
# File 'lib/syntax_tree/node.rb', line 11406

def format(q)
  # If we're in the modifier form and we're modifying a `begin`, then this
  # is a special case where we need to explicitly use the modifier form
  # because otherwise the semantic meaning changes. This looks like:
  #
  #     begin
  #       foo
  #     end while bar
  #
  # Also, if the statement of the modifier includes an assignment, then we
  # can't know for certain that it won't impact the predicate, so we need to
  # force it to stay as it is. This looks like:
  #
  #     foo = bar while foo
  #
  if node.modifier? && (statement = node.statements.body.first) &&
       (statement.is_a?(Begin) || ContainsAssignment.call(statement))
    q.format(statement)
    q.text(" #{keyword} ")
    q.format(node.predicate)
  elsif node.statements.empty?
    q.group do
      q.text("#{keyword} ")
      q.nest(keyword.length + 1) { q.format(node.predicate) }
      q.breakable_force
      q.text("end")
    end
  elsif ContainsAssignment.call(node.predicate)
    format_break(q)
    q.break_parent
  else
    q.group do
      q
        .if_break { format_break(q) }
        .if_flat do
          Parentheses.flat(q) do
            q.format(node.statements)
            q.text(" #{keyword} ")
            q.format(node.predicate)
          end
        end
    end
  end
end