Module: Mongoid::Interceptable

# File 'lib/mongoid/interceptable.rb', line 259

def pending_callbacks
  @pending_callbacks ||= [].to_set
end

# File 'lib/mongoid/interceptable.rb', line 273

def pending_callbacks=(value)
  @pending_callbacks = value
end

# File 'lib/mongoid/interceptable.rb', line 225

def _mongoid_run_child_before_callbacks(kind, children: [], callback_list: [])
  children.each do |child|
    chain = child.__callbacks[child_callback_type(kind, child)]
    env = ActiveSupport::Callbacks::Filters::Environment.new(child, false, nil)
    next_sequence = compile_callbacks(chain)
    unless next_sequence.final?
      Mongoid.logger.warn("Around callbacks are disabled for embedded documents. Skipping around callbacks for #{child.class.name}.")
      Mongoid.logger.warn('To enable around callbacks for embedded documents, set Mongoid::Config.around_callbacks_for_embeds to true.')
    end
    next_sequence.invoke_before(env)
    return false if env.halted

    env.value = !env.halted
    callback_list << [ next_sequence, env ]
  end
  callback_list
end

# File 'lib/mongoid/interceptable.rb', line 148

def _mongoid_run_child_callbacks(kind, children: nil, &block)
  if Mongoid::Config.around_callbacks_for_embeds
    _mongoid_run_child_callbacks_with_around(kind,
                                             children: children,
                                             &block)
  else
    _mongoid_run_child_callbacks_without_around(kind,
                                                children: children,
                                                &block)
  end
end

# File 'lib/mongoid/interceptable.rb', line 169

def _mongoid_run_child_callbacks_with_around(kind, children: nil, &block)
  children ||= cascadable_children(kind)
  with_children = !Mongoid::Config.prevent_multiple_calls_of_embedded_callbacks

  return block&.call if children.empty?

  fibers = children.map do |child|
    Fiber.new do
      child.run_callbacks(child_callback_type(kind, child), with_children: with_children) do
        Fiber.yield
      end
    end
  end

  fibers.each do |fiber|
    fiber.resume
    raise Mongoid::Errors::InvalidAroundCallback unless fiber.alive?
  end

  block&.call

  fibers.reverse.each(&:resume)
end

# File 'lib/mongoid/interceptable.rb', line 202

def _mongoid_run_child_callbacks_without_around(kind, children: nil, &block)
  children ||= cascadable_children(kind)
  callback_list = _mongoid_run_child_before_callbacks(kind, children: children)
  return false if callback_list == false

  value = block&.call
  callback_list.each do |_next_sequence, env|
    env.value &&= value
  end
  return false if _mongoid_run_child_after_callbacks(callback_list: callback_list) == false

  value
end

# File 'lib/mongoid/interceptable.rb', line 60

def callback_executable?(kind)
  respond_to?("_#{kind}_callbacks")
end

# File 'lib/mongoid/interceptable.rb', line 346

def cascadable_child?(kind, child, association)
  return false if %i[initialize find touch].include?(kind)
  return false if kind == :validate && association.validate?

  child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
end

# File 'lib/mongoid/interceptable.rb', line 316

def cascadable_children(kind, children = Set.new)
  embedded_relations.each_pair do |name, association|
    next unless association.cascading_callbacks?

    without_autobuild do
      delayed_pulls = delayed_atomic_pulls[name]
      delayed_unsets = delayed_atomic_unsets[name]
      children.merge(delayed_pulls) if delayed_pulls
      children.merge(delayed_unsets) if delayed_unsets
      relation = send(name)
      Array.wrap(relation).each do |child|
        next if children.include?(child)

        children.add(child) if cascadable_child?(kind, child, association)
        child.send(:cascadable_children, kind, children)
      end
    end
  end
  children.to_a
end

# File 'lib/mongoid/interceptable.rb', line 365

def child_callback_type(kind, child)
  if kind == :update
    return :create if child.new_record?
    return :destroy if child.flagged_for_destroy?

    kind
  else
    kind
  end
end

# File 'lib/mongoid/interceptable.rb', line 430

def compile_callbacks(chain, type = nil)
  if chain.method(:compile).arity == 0
    # ActiveSupport < 7.1
    chain.compile
  else
    # ActiveSupport >= 7.1
    chain.compile(type)
  end
end

# File 'lib/mongoid/interceptable.rb', line 387

def halted_callback_hook(_filter, _name = nil)
  @before_callback_halted = true
end

# File 'lib/mongoid/interceptable.rb', line 73

def in_callback_state?(kind)
  %i[create destroy].include?(kind) || new_record? || flagged_for_destroy? || changed?
end

# File 'lib/mongoid/interceptable.rb', line 88

def run_after_callbacks(*kinds)
  kinds.each do |kind|
    run_targeted_callbacks(:after, kind)
  end
end

# File 'lib/mongoid/interceptable.rb', line 105

def run_before_callbacks(*kinds)
  kinds.each do |kind|
    run_targeted_callbacks(:before, kind)
  end
end

# File 'lib/mongoid/interceptable.rb', line 125

def run_callbacks(kind, with_children: true, skip_if: nil, &block)
  return block&.call if skip_if&.call

  if with_children
    cascadable_children(kind).each do |child|
      return false if child.run_callbacks(child_callback_type(kind, child), with_children: with_children) == false
    end
  end
  if callback_executable?(kind)
    super(kind, &block)
  else
    true
  end
end

# File 'lib/mongoid/interceptable.rb', line 282

def run_pending_callbacks
  pending_callbacks.each do |cb|
    if %i[apply_defaults apply_post_processed_defaults].include?(cb)
      send(cb)
    else
      run_callbacks(cb, with_children: false)
    end
  end
  pending_callbacks.clear
end

# File 'lib/mongoid/interceptable.rb', line 401

def run_targeted_callbacks(place, kind)
  name = "_run__#{place}__#{kind}__callbacks"
  unless respond_to?(name)
    chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
    send("_#{kind}_callbacks").each do |callback|
      chain.append(callback) if callback.kind == place
    end
    self.class.send :define_method, name do
      env = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
      sequence = compile_callbacks(chain)
      sequence.invoke_before(env)
      env.value = !env.halted
      sequence.invoke_after(env)
      env.value
    end
    self.class.send :protected, name
  end
  send(name)
end