Class: SyntaxTree::Params

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

Overview

Params represents defining parameters on a method or lambda.

def method(param) end

Defined Under Namespace

Classes: KeywordFormatter, KeywordRestFormatter, OptionalFormatter

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(location:, requireds: [], optionals: [], rest: nil, posts: [], keywords: [], keyword_rest: nil, block: nil) ⇒ Params

Returns a new instance of Params.



8313
8314
8315
8316
8317
8318
8319
8320
8321
8322
8323
8324
8325
8326
8327
8328
8329
8330
8331
8332
 
# File 'lib/syntax_tree/node.rb', line 8313

def initialize(
  location:,
  requireds: [],
  optionals: [],
  rest: nil,
  posts: [],
  keywords: [],
  keyword_rest: nil,
  block: nil
)
  @requireds = requireds
  @optionals = optionals
  @rest = rest
  @posts = posts
  @keywords = keywords
  @keyword_rest = keyword_rest
  @block = block
  @location = location
  @comments = []
end

Instance Attribute Details

#block ⇒ Object (readonly)

nil | BlockArg

the optional block parameter



8308
8309
8310
 
# File 'lib/syntax_tree/node.rb', line 8308

def block
  @block
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



8311
8312
8313
 
# File 'lib/syntax_tree/node.rb', line 8311

def comments
  @comments
end

#keyword_rest ⇒ Object (readonly)

nil | :nil | ArgsForward | KwRestParam

the optional keyword rest

parameter



8305
8306
8307
 
# File 'lib/syntax_tree/node.rb', line 8305

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

Array[ [ Label, nil | Node

]] any keyword parameters and their

optional default values



8301
8302
8303
 
# File 'lib/syntax_tree/node.rb', line 8301

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

Array[ [ Ident, Node

]] any optional parameters and their default

values



8289
8290
8291
 
# File 'lib/syntax_tree/node.rb', line 8289

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

Array[ Ident | MLHSParen ]

any positional parameters that exist after a

rest parameter



8297
8298
8299
 
# File 'lib/syntax_tree/node.rb', line 8297

def posts
  @posts
end

#requireds ⇒ Object (readonly)

Array[ Ident | MLHSParen ]

any required parameters



8285
8286
8287
 
# File 'lib/syntax_tree/node.rb', line 8285

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

nil | ArgsForward | ExcessedComma | RestParam

the optional rest

parameter



8293
8294
8295
 
# File 'lib/syntax_tree/node.rb', line 8293

def rest
  @rest
end

Instance Method Details

#===(other) ⇒ Object 



8443
8444
8445
8446
8447
8448
8449
8450
8451
8452
8453
8454
8455
 
# File 'lib/syntax_tree/node.rb', line 8443

def ===(other)
  other.is_a?(Params) && ArrayMatch.call(requireds, other.requireds) &&
    optionals.length == other.optionals.length &&
    optionals
      .zip(other.optionals)
      .all? { |left, right| ArrayMatch.call(left, right) } &&
    rest === other.rest && ArrayMatch.call(posts, other.posts) &&
    keywords.length == other.keywords.length &&
    keywords
      .zip(other.keywords)
      .all? { |left, right| ArrayMatch.call(left, right) } &&
    keyword_rest === other.keyword_rest && block === other.block
end

#accept(visitor) ⇒ Object 



8343
8344
8345
 
# File 'lib/syntax_tree/node.rb', line 8343

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

#arity ⇒ Object

Returns a range representing the possible number of arguments accepted by this params node not including the block. For example:

def foo(a, b = 1, c:, d: 2, &block)
  ...
end

has arity 2..4.



8466
8467
8468
8469
8470
8471
8472
8473
8474
8475
8476
8477
8478
 
# File 'lib/syntax_tree/node.rb', line 8466

def arity
  optional_keywords = keywords.count { |_label, value| value }

  lower_bound =
    requireds.length + posts.length + keywords.length - optional_keywords

  upper_bound =
    if keyword_rest.nil? && rest.nil?
      lower_bound + optionals.length + optional_keywords
    end

  lower_bound..upper_bound
end

#child_nodes ⇒ Object Also known as: deconstruct 



8347
8348
8349
8350
8351
8352
8353
8354
8355
8356
8357
8358
8359
 
# File 'lib/syntax_tree/node.rb', line 8347

def child_nodes
  keyword_rest = self.keyword_rest

  [
    *requireds,
    *optionals.flatten(1),
    rest,
    *posts,
    *keywords.flatten(1),
    (keyword_rest if keyword_rest != :nil),
    block
  ]
end

#copy(location: nil, requireds: nil, optionals: nil, rest: nil, posts: nil, keywords: nil, keyword_rest: nil, block: nil) ⇒ Object 



8361
8362
8363
8364
8365
8366
8367
8368
8369
8370
8371
8372
8373
8374
8375
8376
8377
8378
8379
8380
8381
8382
8383
8384
8385
 
# File 'lib/syntax_tree/node.rb', line 8361

def copy(
  location: nil,
  requireds: nil,
  optionals: nil,
  rest: nil,
  posts: nil,
  keywords: nil,
  keyword_rest: nil,
  block: nil
)
  node =
    Params.new(
      location: location || self.location,
      requireds: requireds || self.requireds,
      optionals: optionals || self.optionals,
      rest: rest || self.rest,
      posts: posts || self.posts,
      keywords: keywords || self.keywords,
      keyword_rest: keyword_rest || self.keyword_rest,
      block: block || self.block
    )

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

#deconstruct_keys(_keys) ⇒ Object 



8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
 
# File 'lib/syntax_tree/node.rb', line 8389

def deconstruct_keys(_keys)
  {
    location: location,
    requireds: requireds,
    optionals: optionals,
    rest: rest,
    posts: posts,
    keywords: keywords,
    keyword_rest: keyword_rest,
    block: block,
    comments: comments
  }
end

#empty? ⇒ Boolean

Params nodes are the most complicated in the tree. Occasionally you want to know if they are “empty”, which means not having any parameters declared. This logic accesses every kind of parameter and determines if it’s missing.

Returns:

  • (Boolean) 


8338
8339
8340
8341
 
# File 'lib/syntax_tree/node.rb', line 8338

def empty?
  requireds.empty? && optionals.empty? && !rest && posts.empty? &&
    keywords.empty? && !keyword_rest && !block
end

#format(q) ⇒ Object 



8403
8404
8405
8406
8407
8408
8409
8410
8411
8412
8413
8414
8415
8416
8417
8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
 
# File 'lib/syntax_tree/node.rb', line 8403

def format(q)
  rest = self.rest
  keyword_rest = self.keyword_rest

  parts = [
    *requireds,
    *optionals.map { |(name, value)| OptionalFormatter.new(name, value) }
  ]

  parts << rest if rest && !rest.is_a?(ExcessedComma)
  parts.concat(posts)
  parts.concat(
    keywords.map { |(name, value)| KeywordFormatter.new(name, value) }
  )

  parts << KeywordRestFormatter.new(keyword_rest) if keyword_rest
  parts << block if block

  if parts.empty?
    q.nest(0) { format_contents(q, parts) }
    return
  end

  if q.parent.is_a?(DefNode)
    q.nest(0) do
      q.text("(")
      q.group do
        q.indent do
          q.breakable_empty
          format_contents(q, parts)
        end
        q.breakable_empty
      end
      q.text(")")
    end
  else
    q.nest(0) { format_contents(q, parts) }
  end
end