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, #pretty_print, #to_json

Constructor Details

#initialize(requireds: [], optionals: [], rest: nil, posts: [], keywords: [], keyword_rest: nil, block: nil, location:) ⇒ Params 



8192
8193
8194
8195
8196
8197
8198
8199
8200
8201
8202
8203
8204
8205
8206
8207
8208
8209
8210
8211
 
# File 'lib/syntax_tree/node.rb', line 8192

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



8187
8188
8189
 
# File 'lib/syntax_tree/node.rb', line 8187

def block
  @block
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



8190
8191
8192
 
# File 'lib/syntax_tree/node.rb', line 8190

def comments
  @comments
end

#keyword_rest ⇒ Object (readonly)

nil | :nil | KwRestParam

the optional keyword rest parameter



8184
8185
8186
 
# File 'lib/syntax_tree/node.rb', line 8184

def keyword_rest
  @keyword_rest
end

#keywords ⇒ Object (readonly)

Array[ [ Ident, nil | untyped

]] any keyword parameters and their

optional default values



8181
8182
8183
 
# File 'lib/syntax_tree/node.rb', line 8181

def keywords
  @keywords
end

#optionals ⇒ Object (readonly)

Array[ [ Ident, untyped

]] any optional parameters and their default

values



8169
8170
8171
 
# File 'lib/syntax_tree/node.rb', line 8169

def optionals
  @optionals
end

#posts ⇒ Object (readonly)

Array[ Ident ]

any positional parameters that exist after a rest

parameter



8177
8178
8179
 
# File 'lib/syntax_tree/node.rb', line 8177

def posts
  @posts
end

#requireds ⇒ Object (readonly)

Array[ Ident ]

any required parameters



8165
8166
8167
 
# File 'lib/syntax_tree/node.rb', line 8165

def requireds
  @requireds
end

#rest ⇒ Object (readonly)

nil | ArgsForward | ExcessedComma | RestParam

the optional rest

parameter



8173
8174
8175
 
# File 'lib/syntax_tree/node.rb', line 8173

def rest
  @rest
end

Instance Method Details

#===(other) ⇒ Object 



8317
8318
8319
8320
8321
8322
8323
8324
8325
8326
8327
8328
8329
 
# File 'lib/syntax_tree/node.rb', line 8317

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 



8222
8223
8224
 
# File 'lib/syntax_tree/node.rb', line 8222

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.



8340
8341
8342
8343
8344
8345
8346
8347
8348
8349
8350
8351
8352
 
# File 'lib/syntax_tree/node.rb', line 8340

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 



8226
8227
8228
8229
8230
8231
8232
8233
8234
8235
8236
 
# File 'lib/syntax_tree/node.rb', line 8226

def child_nodes
  [
    *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 



8238
8239
8240
8241
8242
8243
8244
8245
8246
8247
8248
8249
8250
8251
8252
8253
8254
8255
8256
8257
8258
8259
8260
8261
8262
 
# File 'lib/syntax_tree/node.rb', line 8238

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 



8266
8267
8268
8269
8270
8271
8272
8273
8274
8275
8276
8277
8278
 
# File 'lib/syntax_tree/node.rb', line 8266

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.



8217
8218
8219
8220
 
# File 'lib/syntax_tree/node.rb', line 8217

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

#format(q) ⇒ Object 



8280
8281
8282
8283
8284
8285
8286
8287
8288
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309
8310
8311
8312
8313
8314
8315
 
# File 'lib/syntax_tree/node.rb', line 8280

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

  parts << rest if rest && !rest.is_a?(ExcessedComma)
  parts += [
    *posts,
    *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