Class: SyntaxTree::BlockNode

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

Overview

Block represents passing a block to a method call using the do and end keywords or the { and } operators.

method do |value|
end

method { |value| }

Defined Under Namespace

Classes: BlockOpenFormatter

Instance Attribute Summary collapse

Attributes inherited from Node

#location

Instance Method Summary collapse

Methods inherited from Node

#construct_keys, #end_char, #pretty_print, #start_char, #to_json, #to_mermaid

Constructor Details

#initialize(opening:, block_var:, bodystmt:, location:) ⇒ BlockNode

Returns a new instance of BlockNode.



4344
4345
4346
4347
4348
4349
4350
 
# File 'lib/syntax_tree/node.rb', line 4344

def initialize(opening:, block_var:, bodystmt:, location:)
  @opening = opening
  @block_var = block_var
  @bodystmt = bodystmt
  @location = location
  @comments = []
end

Instance Attribute Details

#block_var ⇒ Object (readonly)

nil | BlockVar

the optional variable declaration within this block



4336
4337
4338
 
# File 'lib/syntax_tree/node.rb', line 4336

def block_var
  @block_var
end

#bodystmt ⇒ Object (readonly)

BodyStmt | Statements

the expressions to be executed within this block



4339
4340
4341
 
# File 'lib/syntax_tree/node.rb', line 4339

def bodystmt
  @bodystmt
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



4342
4343
4344
 
# File 'lib/syntax_tree/node.rb', line 4342

def comments
  @comments
end

#opening ⇒ Object (readonly)

LBrace | Kw

the left brace or the do keyword that opens this block



4333
4334
4335
 
# File 'lib/syntax_tree/node.rb', line 4333

def opening
  @opening
end

Instance Method Details

#===(other) ⇒ Object 



4417
4418
4419
4420
 
# File 'lib/syntax_tree/node.rb', line 4417

def ===(other)
  other.is_a?(BlockNode) && opening === other.opening &&
    block_var === other.block_var && bodystmt === other.bodystmt
end

#accept(visitor) ⇒ Object 



4352
4353
4354
 
# File 'lib/syntax_tree/node.rb', line 4352

def accept(visitor)
  visitor.visit_block(self)
end

#arity ⇒ Object 



4426
4427
4428
4429
4430
4431
4432
4433
 
# File 'lib/syntax_tree/node.rb', line 4426

def arity
  case block_var
  when BlockVar
    block_var.params.arity
  else
    0..0
  end
end

#child_nodes ⇒ Object Also known as: deconstruct 



4356
4357
4358
 
# File 'lib/syntax_tree/node.rb', line 4356

def child_nodes
  [opening, block_var, bodystmt]
end

#copy(opening: nil, block_var: nil, bodystmt: nil, location: nil) ⇒ Object 



4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
 
# File 'lib/syntax_tree/node.rb', line 4360

def copy(opening: nil, block_var: nil, bodystmt: nil, location: nil)
  node =
    BlockNode.new(
      opening: opening || self.opening,
      block_var: block_var || self.block_var,
      bodystmt: bodystmt || self.bodystmt,
      location: location || self.location
    )

  node.comments.concat(comments.map(&:copy))
  node
end

#deconstruct_keys(_keys) ⇒ Object 



4375
4376
4377
4378
4379
4380
4381
4382
4383
 
# File 'lib/syntax_tree/node.rb', line 4375

def deconstruct_keys(_keys)
  {
    opening: opening,
    block_var: block_var,
    bodystmt: bodystmt,
    location: location,
    comments: comments
  }
end

#format(q) ⇒ Object 



4385
4386
4387
4388
4389
4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
 
# File 'lib/syntax_tree/node.rb', line 4385

def format(q)
  # If this is nested anywhere inside of a Command or CommandCall node, then
  # we can't change which operators we're using for the bounds of the block.
  break_opening, break_closing, flat_opening, flat_closing =
    if unchangeable_bounds?(q)
      block_close = keywords? ? "end" : "}"
      [opening.value, block_close, opening.value, block_close]
    elsif forced_do_end_bounds?(q)
      %w[do end do end]
    elsif forced_brace_bounds?(q)
      %w[{ } { }]
    else
      %w[do end { }]
    end

  # If the receiver of this block a Command or CommandCall node, then there
  # are no parentheses around the arguments to that command, so we need to
  # break the block.
  case q.parent
  when nil, Command, CommandCall
    q.break_parent
    format_break(q, break_opening, break_closing)
    return
  end

  q.group do
    q
      .if_break { format_break(q, break_opening, break_closing) }
      .if_flat { format_flat(q, flat_opening, flat_closing) }
  end
end

#keywords? ⇒ Boolean

Returns:

  • (Boolean) 


4422
4423
4424
 
# File 'lib/syntax_tree/node.rb', line 4422

def keywords?
  opening.is_a?(Kw)
end