Spec-Zone.ru › Ruby 3.4
  1. Prism::
  2. Диспетчер

класс Prism::Dispatcher

Класс диспетчера генерирует события для узлов, обнаруженных при обходе AST, и передаёт их всем зарегистрированным обработчикам. Он полезен для выполнения различных типов анализа AST, когда дерево нужно обойти всего один раз.

Чтобы использовать диспетчер, сначала создайте его экземпляр и зарегистрируйте обработчики событий, которые вас интересуют:

class OctalListener
  def on_integer_node_enter(node)
    if node.octal? && !node.slice.start_with?("0o")
      warn("Octal integers should be written with the 0o prefix")
    end
  end
end

listener = OctalListener.new
dispatcher = Prism::Dispatcher.new
dispatcher.register(listener, :on_integer_node_enter)

Затем можно обходить любое количество деревьев и передавать события обработчикам:

result = Prism.parse("001 + 002 + 003")
dispatcher.dispatch(result.value)

При желании можно также использовать dispatch_once, чтобы передать события входа и выхода для отдельного узла, не выполняя дальнейший рекурсивный обход дерева. Это может быть полезно, если вы хотите повторно использовать уже зарегистрированные обработчики, но прекратить обход дерева в определённой точке.

integer = result.value.statements.body.first.receiver.receiver
dispatcher.dispatch_once(integer)

Атрибуты

listeners [R]

attr_reader listeners: Hash[Symbol, Array]

Публичные методы класса

new () Показать исходный код
# File lib/prism/dispatcher.rb, line 50
def initialize
  @listeners = {}
end

Инициализирует новый диспетчер.

Открытые методы экземпляра

dispatch_once (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 82
def dispatch_once(node)
  node.accept(DispatchOnce.new(listeners))
end

Отправляет одно событие для node всем зарегистрированным слушателям.

def dispatch_once: (Node) -> void

register (listener, *events) Показать исходный код
# File lib/prism/dispatcher.rb, line 57
def register(listener, *events)
  register_events(listener, events)
end

Регистрирует слушателя для одного или нескольких событий.

def register: (Listener, *Symbol) -> void

register_public_methods (listener) Показать исходный код
# File lib/prism/dispatcher.rb, line 65
def register_public_methods(listener)
  register_events(listener, listener.public_methods(false).grep(/\Aon_.+_(?:enter|leave)\z/))
end

Регистрирует все открытые методы слушателя, соответствующие шаблону on_<node_name>_(enter|leave).

def register_public_methods: (Listener) -> void

visit_alias_global_variable_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 88
def visit_alias_global_variable_node(node)
  listeners[:on_alias_global_variable_node_enter]&.each { |listener| listener.on_alias_global_variable_node_enter(node) }
  super
  listeners[:on_alias_global_variable_node_leave]&.each { |listener| listener.on_alias_global_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов AliasGlobalVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_alias_method_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 96
def visit_alias_method_node(node)
  listeners[:on_alias_method_node_enter]&.each { |listener| listener.on_alias_method_node_enter(node) }
  super
  listeners[:on_alias_method_node_leave]&.each { |listener| listener.on_alias_method_node_leave(node) }
end

Отправляет события входа и выхода для узлов AliasMethodNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_alternation_pattern_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 104
def visit_alternation_pattern_node(node)
  listeners[:on_alternation_pattern_node_enter]&.each { |listener| listener.on_alternation_pattern_node_enter(node) }
  super
  listeners[:on_alternation_pattern_node_leave]&.each { |listener| listener.on_alternation_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов AlternationPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_and_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 112
def visit_and_node(node)
  listeners[:on_and_node_enter]&.each { |listener| listener.on_and_node_enter(node) }
  super
  listeners[:on_and_node_leave]&.each { |listener| listener.on_and_node_leave(node) }
end

Отправляет события входа и выхода для узлов AndNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_arguments_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 120
def visit_arguments_node(node)
  listeners[:on_arguments_node_enter]&.each { |listener| listener.on_arguments_node_enter(node) }
  super
  listeners[:on_arguments_node_leave]&.each { |listener| listener.on_arguments_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArgumentsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_array_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 128
def visit_array_node(node)
  listeners[:on_array_node_enter]&.each { |listener| listener.on_array_node_enter(node) }
  super
  listeners[:on_array_node_leave]&.each { |listener| listener.on_array_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArrayNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_array_pattern_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 136
def visit_array_pattern_node(node)
  listeners[:on_array_pattern_node_enter]&.each { |listener| listener.on_array_pattern_node_enter(node) }
  super
  listeners[:on_array_pattern_node_leave]&.each { |listener| listener.on_array_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArrayPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_assoc_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 144
def visit_assoc_node(node)
  listeners[:on_assoc_node_enter]&.each { |listener| listener.on_assoc_node_enter(node) }
  super
  listeners[:on_assoc_node_leave]&.each { |listener| listener.on_assoc_node_leave(node) }
end

Отправляет события входа и выхода для узлов AssocNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_assoc_splat_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 152
def visit_assoc_splat_node(node)
  listeners[:on_assoc_splat_node_enter]&.each { |listener| listener.on_assoc_splat_node_enter(node) }
  super
  listeners[:on_assoc_splat_node_leave]&.each { |listener| listener.on_assoc_splat_node_leave(node) }
end

Отправляет события входа и выхода для узлов AssocSplatNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_back_reference_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 160
def visit_back_reference_read_node(node)
  listeners[:on_back_reference_read_node_enter]&.each { |listener| listener.on_back_reference_read_node_enter(node) }
  super
  listeners[:on_back_reference_read_node_leave]&.each { |listener| listener.on_back_reference_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов BackReferenceReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_begin_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 168
def visit_begin_node(node)
  listeners[:on_begin_node_enter]&.each { |listener| listener.on_begin_node_enter(node) }
  super
  listeners[:on_begin_node_leave]&.each { |listener| listener.on_begin_node_leave(node) }
end

Отправляет события входа и выхода для узлов BeginNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_argument_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 176
def visit_block_argument_node(node)
  listeners[:on_block_argument_node_enter]&.each { |listener| listener.on_block_argument_node_enter(node) }
  super
  listeners[:on_block_argument_node_leave]&.each { |listener| listener.on_block_argument_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockArgumentNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_local_variable_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 184
def visit_block_local_variable_node(node)
  listeners[:on_block_local_variable_node_enter]&.each { |listener| listener.on_block_local_variable_node_enter(node) }
  super
  listeners[:on_block_local_variable_node_leave]&.each { |listener| listener.on_block_local_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockLocalVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 192
def visit_block_node(node)
  listeners[:on_block_node_enter]&.each { |listener| listener.on_block_node_enter(node) }
  super
  listeners[:on_block_node_leave]&.each { |listener| listener.on_block_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 200
def visit_block_parameter_node(node)
  listeners[:on_block_parameter_node_enter]&.each { |listener| listener.on_block_parameter_node_enter(node) }
  super
  listeners[:on_block_parameter_node_leave]&.each { |listener| listener.on_block_parameter_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_parameters_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 208
def visit_block_parameters_node(node)
  listeners[:on_block_parameters_node_enter]&.each { |listener| listener.on_block_parameters_node_enter(node) }
  super
  listeners[:on_block_parameters_node_leave]&.each { |listener| listener.on_block_parameters_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockParametersNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_break_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 216
def visit_break_node(node)
  listeners[:on_break_node_enter]&.each { |listener| listener.on_break_node_enter(node) }
  super
  listeners[:on_break_node_leave]&.each { |listener| listener.on_break_node_leave(node) }
end

Отправляет события входа и выхода для узлов BreakNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 224
def visit_call_and_write_node(node)
  listeners[:on_call_and_write_node_enter]&.each { |listener| listener.on_call_and_write_node_enter(node) }
  super
  listeners[:on_call_and_write_node_leave]&.each { |listener| listener.on_call_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов CallAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 232
def visit_call_node(node)
  listeners[:on_call_node_enter]&.each { |listener| listener.on_call_node_enter(node) }
  super
  listeners[:on_call_node_leave]&.each { |listener| listener.on_call_node_leave(node) }
end

Отправляет события входа и выхода для узлов CallNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 240
def visit_call_operator_write_node(node)
  listeners[:on_call_operator_write_node_enter]&.each { |listener| listener.on_call_operator_write_node_enter(node) }
  super
  listeners[:on_call_operator_write_node_leave]&.each { |listener| listener.on_call_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов CallOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 248
def visit_call_or_write_node(node)
  listeners[:on_call_or_write_node_enter]&.each { |listener| listener.on_call_or_write_node_enter(node) }
  super
  listeners[:on_call_or_write_node_leave]&.each { |listener| listener.on_call_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов CallOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 256
def visit_call_target_node(node)
  listeners[:on_call_target_node_enter]&.each { |listener| listener.on_call_target_node_enter(node) }
  super
  listeners[:on_call_target_node_leave]&.each { |listener| listener.on_call_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов CallTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_capture_pattern_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 264
def visit_capture_pattern_node(node)
  listeners[:on_capture_pattern_node_enter]&.each { |listener| listener.on_capture_pattern_node_enter(node) }
  super
  listeners[:on_capture_pattern_node_leave]&.each { |listener| listener.on_capture_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов CapturePatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_case_match_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 272
def visit_case_match_node(node)
  listeners[:on_case_match_node_enter]&.each { |listener| listener.on_case_match_node_enter(node) }
  super
  listeners[:on_case_match_node_leave]&.each { |listener| listener.on_case_match_node_leave(node) }
end

Отправляет события входа и выхода для узлов CaseMatchNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_case_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 280
def visit_case_node(node)
  listeners[:on_case_node_enter]&.each { |listener| listener.on_case_node_enter(node) }
  super
  listeners[:on_case_node_leave]&.each { |listener| listener.on_case_node_leave(node) }
end

Отправляет события входа и выхода для узлов CaseNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 288
def visit_class_node(node)
  listeners[:on_class_node_enter]&.each { |listener| listener.on_class_node_enter(node) }
  super
  listeners[:on_class_node_leave]&.each { |listener| listener.on_class_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 296
def visit_class_variable_and_write_node(node)
  listeners[:on_class_variable_and_write_node_enter]&.each { |listener| listener.on_class_variable_and_write_node_enter(node) }
  super
  listeners[:on_class_variable_and_write_node_leave]&.each { |listener| listener.on_class_variable_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 304
def visit_class_variable_operator_write_node(node)
  listeners[:on_class_variable_operator_write_node_enter]&.each { |listener| listener.on_class_variable_operator_write_node_enter(node) }
  super
  listeners[:on_class_variable_operator_write_node_leave]&.each { |listener| listener.on_class_variable_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 312
def visit_class_variable_or_write_node(node)
  listeners[:on_class_variable_or_write_node_enter]&.each { |listener| listener.on_class_variable_or_write_node_enter(node) }
  super
  listeners[:on_class_variable_or_write_node_leave]&.each { |listener| listener.on_class_variable_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 320
def visit_class_variable_read_node(node)
  listeners[:on_class_variable_read_node_enter]&.each { |listener| listener.on_class_variable_read_node_enter(node) }
  super
  listeners[:on_class_variable_read_node_leave]&.each { |listener| listener.on_class_variable_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 328
def visit_class_variable_target_node(node)
  listeners[:on_class_variable_target_node_enter]&.each { |listener| listener.on_class_variable_target_node_enter(node) }
  super
  listeners[:on_class_variable_target_node_leave]&.each { |listener| listener.on_class_variable_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_class_variable_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 336
def visit_class_variable_write_node(node)
  listeners[:on_class_variable_write_node_enter]&.each { |listener| listener.on_class_variable_write_node_enter(node) }
  super
  listeners[:on_class_variable_write_node_leave]&.each { |listener| listener.on_class_variable_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ClassVariableWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 344
def visit_constant_and_write_node(node)
  listeners[:on_constant_and_write_node_enter]&.each { |listener| listener.on_constant_and_write_node_enter(node) }
  super
  listeners[:on_constant_and_write_node_leave]&.each { |listener| listener.on_constant_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 352
def visit_constant_operator_write_node(node)
  listeners[:on_constant_operator_write_node_enter]&.each { |listener| listener.on_constant_operator_write_node_enter(node) }
  super
  listeners[:on_constant_operator_write_node_leave]&.each { |listener| listener.on_constant_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 360
def visit_constant_or_write_node(node)
  listeners[:on_constant_or_write_node_enter]&.each { |listener| listener.on_constant_or_write_node_enter(node) }
  super
  listeners[:on_constant_or_write_node_leave]&.each { |listener| listener.on_constant_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 368
def visit_constant_path_and_write_node(node)
  listeners[:on_constant_path_and_write_node_enter]&.each { |listener| listener.on_constant_path_and_write_node_enter(node) }
  super
  listeners[:on_constant_path_and_write_node_leave]&.each { |listener| listener.on_constant_path_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 376
def visit_constant_path_node(node)
  listeners[:on_constant_path_node_enter]&.each { |listener| listener.on_constant_path_node_enter(node) }
  super
  listeners[:on_constant_path_node_leave]&.each { |listener| listener.on_constant_path_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 384
def visit_constant_path_operator_write_node(node)
  listeners[:on_constant_path_operator_write_node_enter]&.each { |listener| listener.on_constant_path_operator_write_node_enter(node) }
  super
  listeners[:on_constant_path_operator_write_node_leave]&.each { |listener| listener.on_constant_path_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 392
def visit_constant_path_or_write_node(node)
  listeners[:on_constant_path_or_write_node_enter]&.each { |listener| listener.on_constant_path_or_write_node_enter(node) }
  super
  listeners[:on_constant_path_or_write_node_leave]&.each { |listener| listener.on_constant_path_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 400
def visit_constant_path_target_node(node)
  listeners[:on_constant_path_target_node_enter]&.each { |listener| listener.on_constant_path_target_node_enter(node) }
  super
  listeners[:on_constant_path_target_node_leave]&.each { |listener| listener.on_constant_path_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 408
def visit_constant_path_write_node(node)
  listeners[:on_constant_path_write_node_enter]&.each { |listener| listener.on_constant_path_write_node_enter(node) }
  super
  listeners[:on_constant_path_write_node_leave]&.each { |listener| listener.on_constant_path_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 416
def visit_constant_read_node(node)
  listeners[:on_constant_read_node_enter]&.each { |listener| listener.on_constant_read_node_enter(node) }
  super
  listeners[:on_constant_read_node_leave]&.each { |listener| listener.on_constant_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 424
def visit_constant_target_node(node)
  listeners[:on_constant_target_node_enter]&.each { |listener| listener.on_constant_target_node_enter(node) }
  super
  listeners[:on_constant_target_node_leave]&.each { |listener| listener.on_constant_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 432
def visit_constant_write_node(node)
  listeners[:on_constant_write_node_enter]&.each { |listener| listener.on_constant_write_node_enter(node) }
  super
  listeners[:on_constant_write_node_leave]&.each { |listener| listener.on_constant_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_def_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 440
def visit_def_node(node)
  listeners[:on_def_node_enter]&.each { |listener| listener.on_def_node_enter(node) }
  super
  listeners[:on_def_node_leave]&.each { |listener| listener.on_def_node_leave(node) }
end

Отправляет события входа и выхода для узлов DefNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_defined_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 448
def visit_defined_node(node)
  listeners[:on_defined_node_enter]&.each { |listener| listener.on_defined_node_enter(node) }
  super
  listeners[:on_defined_node_leave]&.each { |listener| listener.on_defined_node_leave(node) }
end

Отправляет события входа и выхода для узлов DefinedNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_else_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 456
def visit_else_node(node)
  listeners[:on_else_node_enter]&.each { |listener| listener.on_else_node_enter(node) }
  super
  listeners[:on_else_node_leave]&.each { |listener| listener.on_else_node_leave(node) }
end

Отправляет события входа и выхода для узлов ElseNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_embedded_statements_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 464
def visit_embedded_statements_node(node)
  listeners[:on_embedded_statements_node_enter]&.each { |listener| listener.on_embedded_statements_node_enter(node) }
  super
  listeners[:on_embedded_statements_node_leave]&.each { |listener| listener.on_embedded_statements_node_leave(node) }
end

Отправляет события входа и выхода для узлов EmbeddedStatementsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_embedded_variable_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 472
def visit_embedded_variable_node(node)
  listeners[:on_embedded_variable_node_enter]&.each { |listener| listener.on_embedded_variable_node_enter(node) }
  super
  listeners[:on_embedded_variable_node_leave]&.each { |listener| listener.on_embedded_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов EmbeddedVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_ensure_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 480
def visit_ensure_node(node)
  listeners[:on_ensure_node_enter]&.each { |listener| listener.on_ensure_node_enter(node) }
  super
  listeners[:on_ensure_node_leave]&.each { |listener| listener.on_ensure_node_leave(node) }
end

Отправляет события входа и выхода для узлов EnsureNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_false_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 488
def visit_false_node(node)
  listeners[:on_false_node_enter]&.each { |listener| listener.on_false_node_enter(node) }
  super
  listeners[:on_false_node_leave]&.each { |listener| listener.on_false_node_leave(node) }
end

Отправляет события входа и выхода для узлов FalseNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_find_pattern_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 496
def visit_find_pattern_node(node)
  listeners[:on_find_pattern_node_enter]&.each { |listener| listener.on_find_pattern_node_enter(node) }
  super
  listeners[:on_find_pattern_node_leave]&.each { |listener| listener.on_find_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов FindPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_flip_flop_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 504
def visit_flip_flop_node(node)
  listeners[:on_flip_flop_node_enter]&.each { |listener| listener.on_flip_flop_node_enter(node) }
  super
  listeners[:on_flip_flop_node_leave]&.each { |listener| listener.on_flip_flop_node_leave(node) }
end

Отправляет события входа и выхода для узлов FlipFlopNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_float_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 512
def visit_float_node(node)
  listeners[:on_float_node_enter]&.each { |listener| listener.on_float_node_enter(node) }
  super
  listeners[:on_float_node_leave]&.each { |listener| listener.on_float_node_leave(node) }
end

Отправляет события входа и выхода для узлов FloatNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_for_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 520
def visit_for_node(node)
  listeners[:on_for_node_enter]&.each { |listener| listener.on_for_node_enter(node) }
  super
  listeners[:on_for_node_leave]&.each { |listener| listener.on_for_node_leave(node) }
end

Отправляет события входа и выхода для узлов ForNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_forwarding_arguments_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 528
def visit_forwarding_arguments_node(node)
  listeners[:on_forwarding_arguments_node_enter]&.each { |listener| listener.on_forwarding_arguments_node_enter(node) }
  super
  listeners[:on_forwarding_arguments_node_leave]&.each { |listener| listener.on_forwarding_arguments_node_leave(node) }
end

Отправляет события входа и выхода для узлов ForwardingArgumentsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_forwarding_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 536
def visit_forwarding_parameter_node(node)
  listeners[:on_forwarding_parameter_node_enter]&.each { |listener| listener.on_forwarding_parameter_node_enter(node) }
  super
  listeners[:on_forwarding_parameter_node_leave]&.each { |listener| listener.on_forwarding_parameter_node_leave(node) }
end

Отправляет события входа и выхода для узлов ForwardingParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_forwarding_super_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 544
def visit_forwarding_super_node(node)
  listeners[:on_forwarding_super_node_enter]&.each { |listener| listener.on_forwarding_super_node_enter(node) }
  super
  listeners[:on_forwarding_super_node_leave]&.each { |listener| listener.on_forwarding_super_node_leave(node) }
end

Отправляет события входа и выхода для узлов ForwardingSuperNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 552
def visit_global_variable_and_write_node(node)
  listeners[:on_global_variable_and_write_node_enter]&.each { |listener| listener.on_global_variable_and_write_node_enter(node) }
  super
  listeners[:on_global_variable_and_write_node_leave]&.each { |listener| listener.on_global_variable_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 560
def visit_global_variable_operator_write_node(node)
  listeners[:on_global_variable_operator_write_node_enter]&.each { |listener| listener.on_global_variable_operator_write_node_enter(node) }
  super
  listeners[:on_global_variable_operator_write_node_leave]&.each { |listener| listener.on_global_variable_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 568
def visit_global_variable_or_write_node(node)
  listeners[:on_global_variable_or_write_node_enter]&.each { |listener| listener.on_global_variable_or_write_node_enter(node) }
  super
  listeners[:on_global_variable_or_write_node_leave]&.each { |listener| listener.on_global_variable_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 576
def visit_global_variable_read_node(node)
  listeners[:on_global_variable_read_node_enter]&.each { |listener| listener.on_global_variable_read_node_enter(node) }
  super
  listeners[:on_global_variable_read_node_leave]&.each { |listener| listener.on_global_variable_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 584
def visit_global_variable_target_node(node)
  listeners[:on_global_variable_target_node_enter]&.each { |listener| listener.on_global_variable_target_node_enter(node) }
  super
  listeners[:on_global_variable_target_node_leave]&.each { |listener| listener.on_global_variable_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_global_variable_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 592
def visit_global_variable_write_node(node)
  listeners[:on_global_variable_write_node_enter]&.each { |listener| listener.on_global_variable_write_node_enter(node) }
  super
  listeners[:on_global_variable_write_node_leave]&.each { |listener| listener.on_global_variable_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов GlobalVariableWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_hash_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 600
def visit_hash_node(node)
  listeners[:on_hash_node_enter]&.each { |listener| listener.on_hash_node_enter(node) }
  super
  listeners[:on_hash_node_leave]&.each { |listener| listener.on_hash_node_leave(node) }
end

Отправляет события входа и выхода для узлов HashNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_hash_pattern_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 608
def visit_hash_pattern_node(node)
  listeners[:on_hash_pattern_node_enter]&.each { |listener| listener.on_hash_pattern_node_enter(node) }
  super
  listeners[:on_hash_pattern_node_leave]&.each { |listener| listener.on_hash_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов HashPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_if_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 616
def visit_if_node(node)
  listeners[:on_if_node_enter]&.each { |listener| listener.on_if_node_enter(node) }
  super
  listeners[:on_if_node_leave]&.each { |listener| listener.on_if_node_leave(node) }
end

Отправляет события входа и выхода для узлов IfNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_imaginary_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 624
def visit_imaginary_node(node)
  listeners[:on_imaginary_node_enter]&.each { |listener| listener.on_imaginary_node_enter(node) }
  super
  listeners[:on_imaginary_node_leave]&.each { |listener| listener.on_imaginary_node_leave(node) }
end

Отправляет события входа и выхода для узлов ImaginaryNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_implicit_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 632
def visit_implicit_node(node)
  listeners[:on_implicit_node_enter]&.each { |listener| listener.on_implicit_node_enter(node) }
  super
  listeners[:on_implicit_node_leave]&.each { |listener| listener.on_implicit_node_leave(node) }
end

Отправляет события входа и выхода для узлов ImplicitNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_implicit_rest_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 640
def visit_implicit_rest_node(node)
  listeners[:on_implicit_rest_node_enter]&.each { |listener| listener.on_implicit_rest_node_enter(node) }
  super
  listeners[:on_implicit_rest_node_leave]&.each { |listener| listener.on_implicit_rest_node_leave(node) }
end

Отправляет события входа и выхода для узлов ImplicitRestNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_in_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 648
def visit_in_node(node)
  listeners[:on_in_node_enter]&.each { |listener| listener.on_in_node_enter(node) }
  super
  listeners[:on_in_node_leave]&.each { |listener| listener.on_in_node_leave(node) }
end

Отправляет события входа и выхода для узлов InNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_index_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 656
def visit_index_and_write_node(node)
  listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
  super
  listeners[:on_index_and_write_node_leave]&.each { |listener| listener.on_index_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов IndexAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_index_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 664
def visit_index_operator_write_node(node)
  listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
  super
  listeners[:on_index_operator_write_node_leave]&.each { |listener| listener.on_index_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов IndexOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_index_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 672
def visit_index_or_write_node(node)
  listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
  super
  listeners[:on_index_or_write_node_leave]&.each { |listener| listener.on_index_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов IndexOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_index_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 680
def visit_index_target_node(node)
  listeners[:on_index_target_node_enter]&.each { |listener| listener.on_index_target_node_enter(node) }
  super
  listeners[:on_index_target_node_leave]&.each { |listener| listener.on_index_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов IndexTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 688
def visit_instance_variable_and_write_node(node)
  listeners[:on_instance_variable_and_write_node_enter]&.each { |listener| listener.on_instance_variable_and_write_node_enter(node) }
  super
  listeners[:on_instance_variable_and_write_node_leave]&.each { |listener| listener.on_instance_variable_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 696
def visit_instance_variable_operator_write_node(node)
  listeners[:on_instance_variable_operator_write_node_enter]&.each { |listener| listener.on_instance_variable_operator_write_node_enter(node) }
  super
  listeners[:on_instance_variable_operator_write_node_leave]&.each { |listener| listener.on_instance_variable_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 704
def visit_instance_variable_or_write_node(node)
  listeners[:on_instance_variable_or_write_node_enter]&.each { |listener| listener.on_instance_variable_or_write_node_enter(node) }
  super
  listeners[:on_instance_variable_or_write_node_leave]&.each { |listener| listener.on_instance_variable_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 712
def visit_instance_variable_read_node(node)
  listeners[:on_instance_variable_read_node_enter]&.each { |listener| listener.on_instance_variable_read_node_enter(node) }
  super
  listeners[:on_instance_variable_read_node_leave]&.each { |listener| listener.on_instance_variable_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 720
def visit_instance_variable_target_node(node)
  listeners[:on_instance_variable_target_node_enter]&.each { |listener| listener.on_instance_variable_target_node_enter(node) }
  super
  listeners[:on_instance_variable_target_node_leave]&.each { |listener| listener.on_instance_variable_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_instance_variable_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 728
def visit_instance_variable_write_node(node)
  listeners[:on_instance_variable_write_node_enter]&.each { |listener| listener.on_instance_variable_write_node_enter(node) }
  super
  listeners[:on_instance_variable_write_node_leave]&.each { |listener| listener.on_instance_variable_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов InstanceVariableWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_integer_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 736
def visit_integer_node(node)
  listeners[:on_integer_node_enter]&.each { |listener| listener.on_integer_node_enter(node) }
  super
  listeners[:on_integer_node_leave]&.each { |listener| listener.on_integer_node_leave(node) }
end

Отправляет события входа и выхода для узлов IntegerNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_interpolated_match_last_line_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 744
def visit_interpolated_match_last_line_node(node)
  listeners[:on_interpolated_match_last_line_node_enter]&.each { |listener| listener.on_interpolated_match_last_line_node_enter(node) }
  super
  listeners[:on_interpolated_match_last_line_node_leave]&.each { |listener| listener.on_interpolated_match_last_line_node_leave(node) }
end

Отправляет события входа и выхода для узлов InterpolatedMatchLastLineNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_interpolated_regular_expression_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 752
def visit_interpolated_regular_expression_node(node)
  listeners[:on_interpolated_regular_expression_node_enter]&.each { |listener| listener.on_interpolated_regular_expression_node_enter(node) }
  super
  listeners[:on_interpolated_regular_expression_node_leave]&.each { |listener| listener.on_interpolated_regular_expression_node_leave(node) }
end

Вызывает события входа и выхода для узлов InterpolatedRegularExpressionNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_interpolated_string_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 760
def visit_interpolated_string_node(node)
  listeners[:on_interpolated_string_node_enter]&.each { |listener| listener.on_interpolated_string_node_enter(node) }
  super
  listeners[:on_interpolated_string_node_leave]&.each { |listener| listener.on_interpolated_string_node_leave(node) }
end

Вызывает события входа и выхода для узлов InterpolatedStringNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_interpolated_symbol_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 768
def visit_interpolated_symbol_node(node)
  listeners[:on_interpolated_symbol_node_enter]&.each { |listener| listener.on_interpolated_symbol_node_enter(node) }
  super
  listeners[:on_interpolated_symbol_node_leave]&.each { |listener| listener.on_interpolated_symbol_node_leave(node) }
end

Вызывает события входа и выхода для узлов InterpolatedSymbolNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_interpolated_x_string_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 776
def visit_interpolated_x_string_node(node)
  listeners[:on_interpolated_x_string_node_enter]&.each { |listener| listener.on_interpolated_x_string_node_enter(node) }
  super
  listeners[:on_interpolated_x_string_node_leave]&.each { |listener| listener.on_interpolated_x_string_node_leave(node) }
end

Вызывает события входа и выхода для узлов InterpolatedXStringNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_it_local_variable_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 784
def visit_it_local_variable_read_node(node)
  listeners[:on_it_local_variable_read_node_enter]&.each { |listener| listener.on_it_local_variable_read_node_enter(node) }
  super
  listeners[:on_it_local_variable_read_node_leave]&.each { |listener| listener.on_it_local_variable_read_node_leave(node) }
end

Вызывает события входа и выхода для узлов ItLocalVariableReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_it_parameters_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 792
def visit_it_parameters_node(node)
  listeners[:on_it_parameters_node_enter]&.each { |listener| listener.on_it_parameters_node_enter(node) }
  super
  listeners[:on_it_parameters_node_leave]&.each { |listener| listener.on_it_parameters_node_leave(node) }
end

Вызывает события входа и выхода для узлов ItParametersNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_keyword_hash_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 800
def visit_keyword_hash_node(node)
  listeners[:on_keyword_hash_node_enter]&.each { |listener| listener.on_keyword_hash_node_enter(node) }
  super
  listeners[:on_keyword_hash_node_leave]&.each { |listener| listener.on_keyword_hash_node_leave(node) }
end

Вызывает события входа и выхода для узлов KeywordHashNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_keyword_rest_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 808
def visit_keyword_rest_parameter_node(node)
  listeners[:on_keyword_rest_parameter_node_enter]&.each { |listener| listener.on_keyword_rest_parameter_node_enter(node) }
  super
  listeners[:on_keyword_rest_parameter_node_leave]&.each { |listener| listener.on_keyword_rest_parameter_node_leave(node) }
end

Вызывает события входа и выхода для узлов KeywordRestParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_lambda_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 816
def visit_lambda_node(node)
  listeners[:on_lambda_node_enter]&.each { |listener| listener.on_lambda_node_enter(node) }
  super
  listeners[:on_lambda_node_leave]&.each { |listener| listener.on_lambda_node_leave(node) }
end

Вызывает события входа и выхода для узлов LambdaNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_and_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 824
def visit_local_variable_and_write_node(node)
  listeners[:on_local_variable_and_write_node_enter]&.each { |listener| listener.on_local_variable_and_write_node_enter(node) }
  super
  listeners[:on_local_variable_and_write_node_leave]&.each { |listener| listener.on_local_variable_and_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_operator_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 832
def visit_local_variable_operator_write_node(node)
  listeners[:on_local_variable_operator_write_node_enter]&.each { |listener| listener.on_local_variable_operator_write_node_enter(node) }
  super
  listeners[:on_local_variable_operator_write_node_leave]&.each { |listener| listener.on_local_variable_operator_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_or_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 840
def visit_local_variable_or_write_node(node)
  listeners[:on_local_variable_or_write_node_enter]&.each { |listener| listener.on_local_variable_or_write_node_enter(node) }
  super
  listeners[:on_local_variable_or_write_node_leave]&.each { |listener| listener.on_local_variable_or_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 848
def visit_local_variable_read_node(node)
  listeners[:on_local_variable_read_node_enter]&.each { |listener| listener.on_local_variable_read_node_enter(node) }
  super
  listeners[:on_local_variable_read_node_leave]&.each { |listener| listener.on_local_variable_read_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 856
def visit_local_variable_target_node(node)
  listeners[:on_local_variable_target_node_enter]&.each { |listener| listener.on_local_variable_target_node_enter(node) }
  super
  listeners[:on_local_variable_target_node_leave]&.each { |listener| listener.on_local_variable_target_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_local_variable_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 864
def visit_local_variable_write_node(node)
  listeners[:on_local_variable_write_node_enter]&.each { |listener| listener.on_local_variable_write_node_enter(node) }
  super
  listeners[:on_local_variable_write_node_leave]&.each { |listener| listener.on_local_variable_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов LocalVariableWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_match_last_line_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 872
def visit_match_last_line_node(node)
  listeners[:on_match_last_line_node_enter]&.each { |listener| listener.on_match_last_line_node_enter(node) }
  super
  listeners[:on_match_last_line_node_leave]&.each { |listener| listener.on_match_last_line_node_leave(node) }
end

Вызывает события входа и выхода для узлов MatchLastLineNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_match_predicate_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 880
def visit_match_predicate_node(node)
  listeners[:on_match_predicate_node_enter]&.each { |listener| listener.on_match_predicate_node_enter(node) }
  super
  listeners[:on_match_predicate_node_leave]&.each { |listener| listener.on_match_predicate_node_leave(node) }
end

Вызывает события входа и выхода для узлов MatchPredicateNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_match_required_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 888
def visit_match_required_node(node)
  listeners[:on_match_required_node_enter]&.each { |listener| listener.on_match_required_node_enter(node) }
  super
  listeners[:on_match_required_node_leave]&.each { |listener| listener.on_match_required_node_leave(node) }
end

Вызывает события входа и выхода для узлов MatchRequiredNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_match_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 896
def visit_match_write_node(node)
  listeners[:on_match_write_node_enter]&.each { |listener| listener.on_match_write_node_enter(node) }
  super
  listeners[:on_match_write_node_leave]&.each { |listener| listener.on_match_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов MatchWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_missing_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 904
def visit_missing_node(node)
  listeners[:on_missing_node_enter]&.each { |listener| listener.on_missing_node_enter(node) }
  super
  listeners[:on_missing_node_leave]&.each { |listener| listener.on_missing_node_leave(node) }
end

Вызывает события входа и выхода для узлов MissingNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_module_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 912
def visit_module_node(node)
  listeners[:on_module_node_enter]&.each { |listener| listener.on_module_node_enter(node) }
  super
  listeners[:on_module_node_leave]&.each { |listener| listener.on_module_node_leave(node) }
end

Вызывает события входа и выхода для узлов ModuleNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_multi_target_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 920
def visit_multi_target_node(node)
  listeners[:on_multi_target_node_enter]&.each { |listener| listener.on_multi_target_node_enter(node) }
  super
  listeners[:on_multi_target_node_leave]&.each { |listener| listener.on_multi_target_node_leave(node) }
end

Вызывает события входа и выхода для узлов MultiTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_multi_write_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 928
def visit_multi_write_node(node)
  listeners[:on_multi_write_node_enter]&.each { |listener| listener.on_multi_write_node_enter(node) }
  super
  listeners[:on_multi_write_node_leave]&.each { |listener| listener.on_multi_write_node_leave(node) }
end

Вызывает события входа и выхода для узлов MultiWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_next_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 936
def visit_next_node(node)
  listeners[:on_next_node_enter]&.each { |listener| listener.on_next_node_enter(node) }
  super
  listeners[:on_next_node_leave]&.each { |listener| listener.on_next_node_leave(node) }
end

Вызывает события входа и выхода для узлов NextNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_nil_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 944
def visit_nil_node(node)
  listeners[:on_nil_node_enter]&.each { |listener| listener.on_nil_node_enter(node) }
  super
  listeners[:on_nil_node_leave]&.each { |listener| listener.on_nil_node_leave(node) }
end

Вызывает события входа и выхода для узлов NilNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_no_keywords_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 952
def visit_no_keywords_parameter_node(node)
  listeners[:on_no_keywords_parameter_node_enter]&.each { |listener| listener.on_no_keywords_parameter_node_enter(node) }
  super
  listeners[:on_no_keywords_parameter_node_leave]&.each { |listener| listener.on_no_keywords_parameter_node_leave(node) }
end

Вызывает события входа и выхода для узлов NoKeywordsParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_numbered_parameters_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 960
def visit_numbered_parameters_node(node)
  listeners[:on_numbered_parameters_node_enter]&.each { |listener| listener.on_numbered_parameters_node_enter(node) }
  super
  listeners[:on_numbered_parameters_node_leave]&.each { |listener| listener.on_numbered_parameters_node_leave(node) }
end

Вызывает события входа и выхода для узлов NumberedParametersNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_numbered_reference_read_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 968
def visit_numbered_reference_read_node(node)
  listeners[:on_numbered_reference_read_node_enter]&.each { |listener| listener.on_numbered_reference_read_node_enter(node) }
  super
  listeners[:on_numbered_reference_read_node_leave]&.each { |listener| listener.on_numbered_reference_read_node_leave(node) }
end

Вызывает события входа и выхода для узлов NumberedReferenceReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_optional_keyword_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 976
def visit_optional_keyword_parameter_node(node)
  listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
  super
  listeners[:on_optional_keyword_parameter_node_leave]&.each { |listener| listener.on_optional_keyword_parameter_node_leave(node) }
end

Вызывает события входа и выхода для узлов OptionalKeywordParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_optional_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 984
def visit_optional_parameter_node(node)
  listeners[:on_optional_parameter_node_enter]&.each { |listener| listener.on_optional_parameter_node_enter(node) }
  super
  listeners[:on_optional_parameter_node_leave]&.each { |listener| listener.on_optional_parameter_node_leave(node) }
end

Вызывает события входа и выхода для узлов OptionalParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_or_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 992
def visit_or_node(node)
  listeners[:on_or_node_enter]&.each { |listener| listener.on_or_node_enter(node) }
  super
  listeners[:on_or_node_leave]&.each { |listener| listener.on_or_node_leave(node) }
end

Вызывает события входа и выхода для узлов OrNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_parameters_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1000
def visit_parameters_node(node)
  listeners[:on_parameters_node_enter]&.each { |listener| listener.on_parameters_node_enter(node) }
  super
  listeners[:on_parameters_node_leave]&.each { |listener| listener.on_parameters_node_leave(node) }
end

Вызывает события входа и выхода для узлов ParametersNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_parentheses_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1008
def visit_parentheses_node(node)
  listeners[:on_parentheses_node_enter]&.each { |listener| listener.on_parentheses_node_enter(node) }
  super
  listeners[:on_parentheses_node_leave]&.each { |listener| listener.on_parentheses_node_leave(node) }
end

Вызывает события входа и выхода для узлов ParenthesesNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_pinned_expression_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1016
def visit_pinned_expression_node(node)
  listeners[:on_pinned_expression_node_enter]&.each { |listener| listener.on_pinned_expression_node_enter(node) }
  super
  listeners[:on_pinned_expression_node_leave]&.each { |listener| listener.on_pinned_expression_node_leave(node) }
end

Вызывает события входа и выхода для узлов PinnedExpressionNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_pinned_variable_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1024
def visit_pinned_variable_node(node)
  listeners[:on_pinned_variable_node_enter]&.each { |listener| listener.on_pinned_variable_node_enter(node) }
  super
  listeners[:on_pinned_variable_node_leave]&.each { |listener| listener.on_pinned_variable_node_leave(node) }
end

Вызывает события входа и выхода для узлов PinnedVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_post_execution_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1032
def visit_post_execution_node(node)
  listeners[:on_post_execution_node_enter]&.each { |listener| listener.on_post_execution_node_enter(node) }
  super
  listeners[:on_post_execution_node_leave]&.each { |listener| listener.on_post_execution_node_leave(node) }
end

Вызывает события входа и выхода для узлов PostExecutionNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_pre_execution_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1040
def visit_pre_execution_node(node)
  listeners[:on_pre_execution_node_enter]&.each { |listener| listener.on_pre_execution_node_enter(node) }
  super
  listeners[:on_pre_execution_node_leave]&.each { |listener| listener.on_pre_execution_node_leave(node) }
end

Вызывает события входа и выхода для узлов PreExecutionNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_program_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1048
def visit_program_node(node)
  listeners[:on_program_node_enter]&.each { |listener| listener.on_program_node_enter(node) }
  super
  listeners[:on_program_node_leave]&.each { |listener| listener.on_program_node_leave(node) }
end

Вызывает события входа и выхода для узлов ProgramNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_range_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1056
def visit_range_node(node)
  listeners[:on_range_node_enter]&.each { |listener| listener.on_range_node_enter(node) }
  super
  listeners[:on_range_node_leave]&.each { |listener| listener.on_range_node_leave(node) }
end

Вызывает события входа и выхода для узлов RangeNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_rational_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1064
def visit_rational_node(node)
  listeners[:on_rational_node_enter]&.each { |listener| listener.on_rational_node_enter(node) }
  super
  listeners[:on_rational_node_leave]&.each { |listener| listener.on_rational_node_leave(node) }
end

Вызывает события входа и выхода для узлов RationalNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_redo_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1072
def visit_redo_node(node)
  listeners[:on_redo_node_enter]&.each { |listener| listener.on_redo_node_enter(node) }
  super
  listeners[:on_redo_node_leave]&.each { |listener| listener.on_redo_node_leave(node) }
end

Вызывает события входа и выхода для узлов RedoNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_regular_expression_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1080
def visit_regular_expression_node(node)
  listeners[:on_regular_expression_node_enter]&.each { |listener| listener.on_regular_expression_node_enter(node) }
  super
  listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
end

Вызывает события входа и выхода для узлов RegularExpressionNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_required_keyword_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1088
def visit_required_keyword_parameter_node(node)
  listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
  super
  listeners[:on_required_keyword_parameter_node_leave]&.each { |listener| listener.on_required_keyword_parameter_node_leave(node) }
end

Вызывает события входа и выхода для узлов RequiredKeywordParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_required_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1096
def visit_required_parameter_node(node)
  listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }
  super
  listeners[:on_required_parameter_node_leave]&.each { |listener| listener.on_required_parameter_node_leave(node) }
end

Отправляет события входа и выхода для узлов RequiredParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_rescue_modifier_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1104
def visit_rescue_modifier_node(node)
  listeners[:on_rescue_modifier_node_enter]&.each { |listener| listener.on_rescue_modifier_node_enter(node) }
  super
  listeners[:on_rescue_modifier_node_leave]&.each { |listener| listener.on_rescue_modifier_node_leave(node) }
end

Отправляет события входа и выхода для узлов RescueModifierNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_rescue_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1112
def visit_rescue_node(node)
  listeners[:on_rescue_node_enter]&.each { |listener| listener.on_rescue_node_enter(node) }
  super
  listeners[:on_rescue_node_leave]&.each { |listener| listener.on_rescue_node_leave(node) }
end

Отправляет события входа и выхода для узлов RescueNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_rest_parameter_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1120
def visit_rest_parameter_node(node)
  listeners[:on_rest_parameter_node_enter]&.each { |listener| listener.on_rest_parameter_node_enter(node) }
  super
  listeners[:on_rest_parameter_node_leave]&.each { |listener| listener.on_rest_parameter_node_leave(node) }
end

Отправляет события входа и выхода для узлов RestParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_retry_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1128
def visit_retry_node(node)
  listeners[:on_retry_node_enter]&.each { |listener| listener.on_retry_node_enter(node) }
  super
  listeners[:on_retry_node_leave]&.each { |listener| listener.on_retry_node_leave(node) }
end

Отправляет события входа и выхода для узлов RetryNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_return_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1136
def visit_return_node(node)
  listeners[:on_return_node_enter]&.each { |listener| listener.on_return_node_enter(node) }
  super
  listeners[:on_return_node_leave]&.each { |listener| listener.on_return_node_leave(node) }
end

Отправляет события входа и выхода для узлов ReturnNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_self_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1144
def visit_self_node(node)
  listeners[:on_self_node_enter]&.each { |listener| listener.on_self_node_enter(node) }
  super
  listeners[:on_self_node_leave]&.each { |listener| listener.on_self_node_leave(node) }
end

Отправляет события входа и выхода для узлов SelfNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_shareable_constant_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1152
def visit_shareable_constant_node(node)
  listeners[:on_shareable_constant_node_enter]&.each { |listener| listener.on_shareable_constant_node_enter(node) }
  super
  listeners[:on_shareable_constant_node_leave]&.each { |listener| listener.on_shareable_constant_node_leave(node) }
end

Отправляет события входа и выхода для узлов ShareableConstantNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_singleton_class_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1160
def visit_singleton_class_node(node)
  listeners[:on_singleton_class_node_enter]&.each { |listener| listener.on_singleton_class_node_enter(node) }
  super
  listeners[:on_singleton_class_node_leave]&.each { |listener| listener.on_singleton_class_node_leave(node) }
end

Отправляет события входа и выхода для узлов SingletonClassNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_source_encoding_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1168
def visit_source_encoding_node(node)
  listeners[:on_source_encoding_node_enter]&.each { |listener| listener.on_source_encoding_node_enter(node) }
  super
  listeners[:on_source_encoding_node_leave]&.each { |listener| listener.on_source_encoding_node_leave(node) }
end

Отправляет события входа и выхода для узлов SourceEncodingNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_source_file_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1176
def visit_source_file_node(node)
  listeners[:on_source_file_node_enter]&.each { |listener| listener.on_source_file_node_enter(node) }
  super
  listeners[:on_source_file_node_leave]&.each { |listener| listener.on_source_file_node_leave(node) }
end

Отправляет события входа и выхода для узлов SourceFileNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_source_line_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1184
def visit_source_line_node(node)
  listeners[:on_source_line_node_enter]&.each { |listener| listener.on_source_line_node_enter(node) }
  super
  listeners[:on_source_line_node_leave]&.each { |listener| listener.on_source_line_node_leave(node) }
end

Отправляет события входа и выхода для узлов SourceLineNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_splat_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1192
def visit_splat_node(node)
  listeners[:on_splat_node_enter]&.each { |listener| listener.on_splat_node_enter(node) }
  super
  listeners[:on_splat_node_leave]&.each { |listener| listener.on_splat_node_leave(node) }
end

Отправляет события входа и выхода для узлов SplatNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_statements_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1200
def visit_statements_node(node)
  listeners[:on_statements_node_enter]&.each { |listener| listener.on_statements_node_enter(node) }
  super
  listeners[:on_statements_node_leave]&.each { |listener| listener.on_statements_node_leave(node) }
end

Отправляет события входа и выхода для узлов StatementsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_string_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1208
def visit_string_node(node)
  listeners[:on_string_node_enter]&.each { |listener| listener.on_string_node_enter(node) }
  super
  listeners[:on_string_node_leave]&.each { |listener| listener.on_string_node_leave(node) }
end

Отправляет события входа и выхода для узлов StringNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_super_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1216
def visit_super_node(node)
  listeners[:on_super_node_enter]&.each { |listener| listener.on_super_node_enter(node) }
  super
  listeners[:on_super_node_leave]&.each { |listener| listener.on_super_node_leave(node) }
end

Отправляет события входа и выхода для узлов SuperNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_symbol_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1224
def visit_symbol_node(node)
  listeners[:on_symbol_node_enter]&.each { |listener| listener.on_symbol_node_enter(node) }
  super
  listeners[:on_symbol_node_leave]&.each { |listener| listener.on_symbol_node_leave(node) }
end

Отправляет события входа и выхода для узлов SymbolNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_true_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1232
def visit_true_node(node)
  listeners[:on_true_node_enter]&.each { |listener| listener.on_true_node_enter(node) }
  super
  listeners[:on_true_node_leave]&.each { |listener| listener.on_true_node_leave(node) }
end

Отправляет события входа и выхода для узлов TrueNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_undef_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1240
def visit_undef_node(node)
  listeners[:on_undef_node_enter]&.each { |listener| listener.on_undef_node_enter(node) }
  super
  listeners[:on_undef_node_leave]&.each { |listener| listener.on_undef_node_leave(node) }
end

Отправляет события входа и выхода для узлов UndefNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_unless_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1248
def visit_unless_node(node)
  listeners[:on_unless_node_enter]&.each { |listener| listener.on_unless_node_enter(node) }
  super
  listeners[:on_unless_node_leave]&.each { |listener| listener.on_unless_node_leave(node) }
end

Отправляет события входа и выхода для узлов UnlessNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_until_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1256
def visit_until_node(node)
  listeners[:on_until_node_enter]&.each { |listener| listener.on_until_node_enter(node) }
  super
  listeners[:on_until_node_leave]&.each { |listener| listener.on_until_node_leave(node) }
end

Отправляет события входа и выхода для узлов UntilNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_when_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1264
def visit_when_node(node)
  listeners[:on_when_node_enter]&.each { |listener| listener.on_when_node_enter(node) }
  super
  listeners[:on_when_node_leave]&.each { |listener| listener.on_when_node_leave(node) }
end

Отправляет события входа и выхода для узлов WhenNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_while_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1272
def visit_while_node(node)
  listeners[:on_while_node_enter]&.each { |listener| listener.on_while_node_enter(node) }
  super
  listeners[:on_while_node_leave]&.each { |listener| listener.on_while_node_leave(node) }
end

Отправляет события входа и выхода для узлов WhileNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_x_string_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1280
def visit_x_string_node(node)
  listeners[:on_x_string_node_enter]&.each { |listener| listener.on_x_string_node_enter(node) }
  super
  listeners[:on_x_string_node_leave]&.each { |listener| listener.on_x_string_node_leave(node) }
end

Отправляет события входа и выхода для узлов XStringNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_yield_node (node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1288
def visit_yield_node(node)
  listeners[:on_yield_node_enter]&.each { |listener| listener.on_yield_node_enter(node) }
  super
  listeners[:on_yield_node_leave]&.each { |listener| listener.on_yield_node_leave(node) }
end

Отправляет события входа и выхода для узлов YieldNode и продолжает обход дерева.

Вызывает метод суперкласса

Приватные методы экземпляра

register_events (listener, events) Показать исходный код
# File lib/prism/dispatcher.rb, line 70
        def register_events(listener, events)
  events.each { |event| (listeners[event] ||= []) << listener }
end

Регистрирует слушателя для указанных событий.

Ruby Core © 1993–2025 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API