Class: SyntaxTree::ConditionalFormatter

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

Overview

Formats an If or Unless node.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(keyword, node) ⇒ ConditionalFormatter

Returns a new instance of ConditionalFormatter.



6214
6215
6216
6217
 
# File 'lib/syntax_tree/node.rb', line 6214

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

Instance Attribute Details

#keyword ⇒ Object (readonly)

String

the keyword associated with this conditional



6209
6210
6211
 
# File 'lib/syntax_tree/node.rb', line 6209

def keyword
  @keyword
end

#node ⇒ Object (readonly)

If | Unless

the node that is being formatted



6212
6213
6214
 
# File 'lib/syntax_tree/node.rb', line 6212

def node
  @node
end

Instance Method Details

#format(q) ⇒ Object 



6219
6220
6221
6222
6223
6224
6225
6226
6227
6228
6229
6230
6231
6232
6233
6234
6235
6236
6237
6238
6239
6240
6241
6242
6243
6244
6245
6246
6247
6248
6249
6250
6251
6252
6253
6254
6255
6256
6257
6258
6259
6260
6261
6262
6263
6264
6265
6266
 
# File 'lib/syntax_tree/node.rb', line 6219

def format(q)
  if node.modifier?
    statement = node.statements.body[0]

    if ContainsAssignment.call(statement) || q.parent.is_a?(In)
      q.group { format_flat(q) }
    else
      q.group do
        q
          .if_break { format_break(q, force: false) }
          .if_flat { format_flat(q) }
      end
    end
  else
    # If we can transform this node into a ternary, then we're going to
    # print a special version that uses the ternary operator if it fits on
    # one line.
    if Ternaryable.call(q, node)
      format_ternary(q)
      return
    end

    # If the predicate of the conditional contains an assignment (in which
    # case we can't know for certain that that assignment doesn't impact the
    # statements inside the conditional) then we can't use the modifier form
    # and we must use the block form.
    if ContainsAssignment.call(node.predicate)
      format_break(q, force: true)
      return
    end

    if node.consequent || node.statements.empty? || contains_conditional?
      q.group { format_break(q, force: true) }
    else
      q.group do
        q
          .if_break { format_break(q, force: false) }
          .if_flat do
            Parentheses.flat(q) do
              q.format(node.statements)
              q.text(" #{keyword} ")
              q.format(node.predicate)
            end
          end
      end
    end
  end
end