Class: SyntaxTree::DefNode

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

Overview

Def represents defining a regular method on the current self object.

def method(param) result end
def object.method(param) result end

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(target:, operator:, name:, params:, bodystmt:, location:) ⇒ DefNode

Returns a new instance of DefNode.



4117
4118
4119
4120
4121
4122
4123
4124
4125
 
# File 'lib/syntax_tree/node.rb', line 4117

def initialize(target:, operator:, name:, params:, bodystmt:, location:)
  @target = target
  @operator = operator
  @name = name
  @params = params
  @bodystmt = bodystmt
  @location = location
  @comments = []
end

Instance Attribute Details

#bodystmt ⇒ Object (readonly)

BodyStmt | Node

the expressions to be executed by the method



4112
4113
4114
 
# File 'lib/syntax_tree/node.rb', line 4112

def bodystmt
  @bodystmt
end

#comments ⇒ Object (readonly)

Array[ Comment | EmbDoc ]

the comments attached to this node



4115
4116
4117
 
# File 'lib/syntax_tree/node.rb', line 4115

def comments
  @comments
end

#name ⇒ Object (readonly)

Backtick | Const | Ident | Kw | Op

the name of the method



4106
4107
4108
 
# File 'lib/syntax_tree/node.rb', line 4106

def name
  @name
end

#operator ⇒ Object (readonly)

nil | Op | Period

the operator being used to declare the method



4103
4104
4105
 
# File 'lib/syntax_tree/node.rb', line 4103

def operator
  @operator
end

#params ⇒ Object (readonly)

nil | Params | Paren

the parameter declaration for the method



4109
4110
4111
 
# File 'lib/syntax_tree/node.rb', line 4109

def params
  @params
end

#target ⇒ Object (readonly)

nil | Node

the target where the method is being defined



4100
4101
4102
 
# File 'lib/syntax_tree/node.rb', line 4100

def target
  @target
end

Instance Method Details

#===(other) ⇒ Object 



4217
4218
4219
4220
4221
 
# File 'lib/syntax_tree/node.rb', line 4217

def ===(other)
  other.is_a?(DefNode) && target === other.target &&
    operator === other.operator && name === other.name &&
    params === other.params && bodystmt === other.bodystmt
end

#accept(visitor) ⇒ Object 



4127
4128
4129
 
# File 'lib/syntax_tree/node.rb', line 4127

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

#arity ⇒ Object 



4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
 
# File 'lib/syntax_tree/node.rb', line 4230

def arity
  params = self.params

  case params
  when Params
    params.arity
  when Paren
    params.contents.arity
  else
    0..0
  end
end

#child_nodes ⇒ Object Also known as: deconstruct 



4131
4132
4133
 
# File 'lib/syntax_tree/node.rb', line 4131

def child_nodes
  [target, operator, name, params, bodystmt]
end

#copy(target: nil, operator: nil, name: nil, params: nil, bodystmt: nil, location: nil) ⇒ Object 



4135
4136
4137
4138
4139
4140
4141
4142
4143
4144
4145
4146
4147
4148
4149
4150
4151
4152
4153
4154
4155
 
# File 'lib/syntax_tree/node.rb', line 4135

def copy(
  target: nil,
  operator: nil,
  name: nil,
  params: nil,
  bodystmt: nil,
  location: nil
)
  node =
    DefNode.new(
      target: target || self.target,
      operator: operator || self.operator,
      name: name || self.name,
      params: params || self.params,
      bodystmt: bodystmt || self.bodystmt,
      location: location || self.location
    )

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

#deconstruct_keys(_keys) ⇒ Object 



4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169
 
# File 'lib/syntax_tree/node.rb', line 4159

def deconstruct_keys(_keys)
  {
    target: target,
    operator: operator,
    name: name,
    params: params,
    bodystmt: bodystmt,
    location: location,
    comments: comments
  }
end

#endless? ⇒ Boolean

Returns true if the method was found in the source in the “endless” form, i.e. where the method body is defined using the ‘=` operator after the method name and parameters.

Returns:

  • (Boolean) 


4226
4227
4228
 
# File 'lib/syntax_tree/node.rb', line 4226

def endless?
  !bodystmt.is_a?(BodyStmt)
end

#format(q) ⇒ Object 



4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183
4184
4185
4186
4187
4188
4189
4190
4191
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
 
# File 'lib/syntax_tree/node.rb', line 4171

def format(q)
  params = self.params
  bodystmt = self.bodystmt

  q.group do
    q.group do
      q.text("def")
      q.text(" ") if target || name.comments.empty?

      if target
        q.format(target)
        q.format(CallOperatorFormatter.new(operator), stackable: false)
      end

      q.format(name)

      case params
      when Paren
        q.format(params)
      when Params
        q.format(params) if !params.empty? || params.comments.any?
      end
    end

    if endless?
      q.text(" =")
      q.group do
        q.indent do
          q.breakable_space
          q.format(bodystmt)
        end
      end
    else
      unless bodystmt.empty?
        q.indent do
          q.breakable_force
          q.format(bodystmt)
        end
      end

      q.breakable_force
      q.text("end")
    end
  end
end