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.



4295
4296
4297
4298
4299
4300
4301
 
# File 'lib/syntax_tree/node.rb', line 4295

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



4287
4288
4289
 
# File 'lib/syntax_tree/node.rb', line 4287

def block_var
  @block_var
end

#bodystmt ⇒ Object (readonly)

BodyStmt | Statements

the expressions to be executed within this block



4290
4291
4292
 
# File 'lib/syntax_tree/node.rb', line 4290

def bodystmt
  @bodystmt
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



4293
4294
4295
 
# File 'lib/syntax_tree/node.rb', line 4293

def comments
  @comments
end

#opening ⇒ Object (readonly)

LBrace | Kw

the left brace or the do keyword that opens this block



4284
4285
4286
 
# File 'lib/syntax_tree/node.rb', line 4284

def opening
  @opening
end

Instance Method Details

#===(other) ⇒ Object 



4368
4369
4370
4371
 
# File 'lib/syntax_tree/node.rb', line 4368

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

#accept(visitor) ⇒ Object 



4303
4304
4305
 
# File 'lib/syntax_tree/node.rb', line 4303

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

#arity ⇒ Object 



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

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

#child_nodes ⇒ Object Also known as: deconstruct 



4307
4308
4309
 
# File 'lib/syntax_tree/node.rb', line 4307

def child_nodes
  [opening, block_var, bodystmt]
end

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



4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
 
# File 'lib/syntax_tree/node.rb', line 4311

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 



4326
4327
4328
4329
4330
4331
4332
4333
4334
 
# File 'lib/syntax_tree/node.rb', line 4326

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

#format(q) ⇒ Object 



4336
4337
4338
4339
4340
4341
4342
4343
4344
4345
4346
4347
4348
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
 
# File 'lib/syntax_tree/node.rb', line 4336

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) 


4373
4374
4375
 
# File 'lib/syntax_tree/node.rb', line 4373

def keywords?
  opening.is_a?(Kw)
end