inform-runtime 1.0.4

data/lib/runtime/events.rb

@@ -0,0 +1,771 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2023 but freely usable (see license)
+#
+# This file is part of the Inform Runtime.
+#
+# The Inform Runtime is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The Inform Runtime is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the Inform Runtime.  If not, see <http://www.gnu.org/licenses/>.
+
+# The Time class
+class Time
+  def to_ms
+    (self.to_f * 1000.0).to_i
+  end
+
+  def self.ns
+    self.now.to_f
+  end
+
+  def self.ms
+    self.now.to_ms
+  end
+
+  def self.s
+    self.now.to_i
+  end
+end
+
+# Re-open the Proc class to define #to_lambda
+class Proc
+  WRONG_NUMBER_ARGUMENTS_MESSAGE =
+    "Wrong number of arguments (given %<args>s, expected %<arity>s)".freeze
+
+  # rubocop: disable Metrics/MethodLength
+  # rubocop: disable Style/Lambda
+  def to_lambda
+    return self if lambda?
+    # Save local reference to self so we can use it in the following lambda scope
+    source_proc = self
+    ->(*args, **kwargs, &block) do
+      # Enforce strict arity like a lambda
+      source_arity = source_proc.arity
+      if source_arity >= 0 && args.length != source_arity
+        raise ArgumentError, format(
+          WRONG_NUMBER_ARGUMENTS_MESSAGE, args: args.length, arity: source_arity)
+      elsif args.length < (min = -source_arity - 1)
+        raise ArgumentError, format(
+          WRONG_NUMBER_ARGUMENTS_MESSAGE, args: args.length, arity: "#{min}+")
+      end
+      # Preserve original binding/locals/self
+      source_proc.call(*args, **kwargs, &block)
+    end
+  end
+  # rubocop: enable Metrics/MethodLength
+  # rubocop: enable Style/Lambda
+end
+
+# The Inform module
+module Inform
+  # The EventCauseRecordNotFoundError class
+  class EventCauseRecordNotFoundError < StandardError; end
+end
+
+module EventConstants
+  EventNameTemplate = 'event:%<time>s'.freeze
+  EventCauseIdentityTemplate = '%<identity>s:%<name>s'.freeze
+  EventSourceTemplate = ':%<source_location>s:%<source_line_number>s'.freeze
+  EventSourceFullTemplate = ':%<method_name>s:%<source_location>s:%<source_line_number>s'.freeze
+  EventActivityTemplate = ':%<activity>s'.freeze
+  EventAntecedantTemplate = ' < %<antecedent>s'.freeze
+  CallerPattern = %r{([^:]+):([^:]+):in `([^']+)'}.freeze
+end
+
+# The PublicEventMethods module
+module PublicEventMethods
+  include EventConstants
+
+  def contextualize(from)
+    # log.info "Initializing context for event #{self} from #{from} (#{from.class})"
+    Inform::Context.each_attribute(from) do |attribute, value|
+      warn_when_nilling_noun(from, self, attribute, value)
+      send(Inform::Context.setter_method(attribute), value)
+    end
+  end
+
+  # TODO: Remove
+  def warn_when_nilling_noun(from, to, attribute, value)
+    return unless attribute == :noun
+    return unless value.nil?
+    return if (current_value = to.send(attribute)).nil?
+    return if attribute == :parameters && current_value <= 1
+    log.debug "Overwriting #{to}.#{attribute} (#{current_value}) with #{from}.#{attribute} (nil)!"
+    log.debug " #{to}.context: #{to.context.inspect}"
+    maybe_log_nilling_warning(to.callstack)
+  end
+
+  # TODO: Remove
+  def maybe_log_nilling_warning(callstack)
+    return if callstack.grep('channel_read')
+    ['===========', (caller[-4...] + callstack), '==========='].each { |t| log.warn t unless t.nil? }
+  end
+
+  def <<(event)
+    @successors.add event
+    event.antecedent = self
+  end
+
+  def origin(x = self)
+    x = origin x.antecedent if x.antecedent
+    x.object? ? x : x.cause
+  end
+
+  def termination(x = self)
+    event = x.successors.first
+    event || x.terminus
+  end
+
+  def elemental?
+    @type == :elemental
+  end
+
+  def integral?
+    @type == :integral
+  end
+
+  def immediately?
+    @when == :immediately
+  end
+
+  def cancelled?
+    return true if future.nil?
+    future.cancelled?
+  end
+
+  def antecedent_cancelled?
+    return false if self.antecedent.nil?
+    return false unless self.antecedent.cancelled?
+    return false if self.terminus.nil?
+    log.warn "Event antecedent #{self.antecedent} was cancelled"
+    true
+  end
+
+  def concluded?
+    semaphore.synchronize { concluded == true }
+  end
+
+  def get
+    if future.respond_to?(:get)
+      future.get
+    elsif future.respond_to?(:call)
+      future.call
+    end
+    future
+  rescue SystemExit => e
+    raise e
+  # rescue EventCancelled => e
+  #   log.warn "Cancelled #{event}"
+  #   log.debug "Reason for event cancellation: #{e}"
+  rescue StandardError => e
+    log.error "Event execution exception: #{e.message}"
+  end
+
+  def java_get
+    self.future.get
+    self.future
+  rescue SystemExit => e
+    raise e
+  rescue Java::JavaUtilConcurrent::CancellationException => e
+    log.warn "Cancelled #{event}"
+    log.debug "Reason for event cancellation: #{e}"
+  rescue Java::JavaUtilConcurrent::ExecutionException => e
+    log.error "Event execution exception: #{e.message}"
+  end
+
+  def now(params = {}, &block)
+    # TODO: Determine if :cause should be overwritten
+    # by any :cause params given by the params Hash
+    Inform::Event.new({ cause: cause, antecedent: self }.merge(params), &block)
+  end
+  alias add_event now
+  alias event now
+  alias and_then now
+  alias chain now
+  alias eventually now
+  alias later now
+
+  # Shortcut for using delays
+  def delay(delay, &block)
+    Inform::Event.new({ cause: cause, antecedent: self, delay: delay }, &block)
+  end
+  alias after_delay delay
+
+  def finally(&block)
+    Inform::Event.new({ cause: cause, antecedent: self, terminus: true }, &block)
+  end
+  alias on_cancel finally
+  alias when_completed finally
+  alias when_done finally
+  alias when_finished finally
+  alias when_over finally
+  alias ultimately finally
+
+  def parse_activity
+    self.cause.parse(self.activity)
+  end
+
+  def call_activity
+    return self.activity.call(self) if self.activity.arity == 1
+    self.activity.call(*self.args)
+  end
+
+  # java_signature 'V call()'
+  def call
+    process(self)
+  end
+
+  # java_signature 'void run()'
+  def run
+    call
+  end
+
+  def on_failure(_cause)
+    cancelled
+  end
+
+  def on_success(_result)
+    completed
+  end
+
+  def on_cancelled_antecedent
+    schedule self unless terminus.nil?
+    successors.each(&:on_cancelled_antecedent)
+  end
+
+  def to_s
+    self.identity
+  end
+
+  def inspect
+    format(EventCauseIdentityTemplate, identity: @cause.identity, name: @cause.name)
+  end
+
+  RecordNotFoundErrorPattern = %r{Record not found}.freeze
+
+  def mandate_cause_record_exists!
+    self.cause.refresh
+  rescue StandardError => e
+    if RecordNotFoundErrorPattern.match?(e.message)
+      message = e.message + ' for cause of event ' + self.to_s
+      raise Inform::EventCauseRecordNotFoundError, message
+    end
+    log.warn "Unexpected error refreshing event cause object: #{e.message}"
+  end
+end
+# module PublicEventMethods
+
+# The PrivateEventMethods module
+module PrivateEventMethods
+  private
+
+  def to_java_future(future)
+    future.to_java(com.google.common.util.concurrent.ListenableFuture)
+  end
+
+  # TODO: Implement a mechanism by which new event scheduling may
+  # be deferred or discarded entirely.  The reason for this is that
+  # during shutdown, there will certainly be ongoing events which
+  # require some form of state resolution.  The spinning top, for
+  # instance -- once spun, is given the spinning attribute. Now,
+  # perhaps this is unnecessary, but the case remains that the state
+  # of the top must be returned to its resting state even though the
+  # game is being shutdown.  Perhaps a special on_cancel hook could
+  # be provided for such events which require such state resolution.
+  # Otherwise, at this point, some way of deciding if incoming
+  # events are newly spawned, or if they are part of a chain of
+  # events which must be allowed to transpire for the sake of an
+  # object's state consistency.
+  # rubocop: disable Metrics/AbcSize
+  def schedule(event, delay = 0)
+    raise "The event parameter may not be nil" if event.nil?
+    delay = event.time_delay.to_f * 1000 if event.time_delay > 0
+    schedule_event(event, delay)
+    add_future_callback(event, Inform::Events.scheduler)
+    event.cause.events << event
+    Inform::Events.active_objects << event.cause unless active?(event.cause)
+    event.future
+  end
+  # rubocop: enable Metrics/AbcSize
+
+  def active?(obj)
+    Inform::Events.active_objects.include?(obj)
+  end
+
+  def schedule_event(event, delay)
+    event.future = if defined?(Java)
+      Inform::Events.scheduler.schedule(event, delay, TimeUnit::MILLISECONDS)
+    else
+      # TODO: Implement
+      Inform::Events.scheduler.schedule(event, delay)
+    end
+  end
+
+  def add_future_callback(event, executor)
+    if defined?(java)
+      Futures.addCallback(to_java_future(event.future), event, executor)
+    else
+      # TODO: Implement
+      event.future
+    end
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/MethodLength
+  def process(event)
+    raise "The event parameter may not be nil" if event.nil?
+    Thread.current[:event] = event
+    event.mandate_cause_record_exists!
+    # TODO: This is probably racey so consider wrapping this in a semaphore.
+    return if event.antecedent_cancelled?
+    case event.activity
+    when String
+      result = event.parse_activity
+      # event.cause.inflib&.println(result)
+      # event.cause.println(result)
+      handle(event, result)
+    when Proc
+      result = event.call_activity
+      # event.cause.inflib&.print_evented_zmachine_result(event.call_activity, isolate: event.elemental?)
+      # event.cause.print_evented_zmachine_result(result, isolate: event.elemental?)
+      handle(event, result)
+    else
+      log.error "Event activity type is unknown: #{event.activity} (#{event.activity.class})"
+    end
+  rescue Inform::EventCauseRecordNotFoundError => e
+    log.error "Error refreshing cause object: #{e.message}"
+  rescue LocalJumpError => e
+    # It is a shame that this happens.  It used to not happen, so long
+    # as event.activity was wrapped in lambda(event.activity).
+    # Then one day, this exception began to be thrown again.
+    # TODO: Either use this kludgey hack to fix it:
+    # https://stackoverflow.com/questions/2946603/ruby-convert-proc-to-lambda
+    # https://stackoverflow.com/a/24965981/328469
+    # Or, try to get jruby fixed:
+    # https://github.com/jruby/jruby/issues/4369 (2016)
+    # https://github.com/jruby/jruby/pull/4423 (2017)
+    # https://github.com/jruby/jruby/issues/4577 (2017)
+    log.warn "Event block used return keyword: #{e.message}"
+    log.debug "Local jump error: #{e.message}"
+    e.backtrace.each { |t| log.warn t }
+  rescue SystemExit => e
+    raise e
+  rescue StandardError => e
+    log << "\n"
+    log.error "Unexpected error processing #{event}: #{e.message}", e
+    event.callstack.each { |t| log.error t }
+  ensure
+    Thread.current[:event] = nil
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/MethodLength
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/MethodLength
+  def invoke(event)
+    raise "The event parameter may not be nil" if event.nil?
+    event.antecedent << event if !event.antecedent.nil? && !event.antecedent.concluded?
+    se = Thread.current[:event]
+    Thread.current[:event] = event
+    log.debug "Queueing #{event}"
+    invoke_event(event)
+    add_future_callback(event, Inform::Events.pool)
+    event.cause.events << event
+    Inform::Events.active_objects << event.cause unless Inform::Events.active_objects.include?(event.cause)
+    return defined?(Java) ? event.java_get : event.get
+  rescue StandardError => e
+    log.error "Unexpected error invoking #{event}: #{e.message}", e
+    event.callstack.each { |t| log.error t }
+  ensure
+    Thread.current[:event] = se
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/MethodLength
+
+  def invoke_event(event)
+    event.future = if defined?(Java)
+      Inform::Events.pool.java_send(:submit, [java.lang.Runnable], event)
+    else
+      -> { event.call }
+    end
+  end
+
+  def handle(event, result)
+    case result
+    when String
+      event.cause.println result
+    end
+  end
+
+  def deactivate(obj)
+    raise "The obj parameter may not be nil" if obj.nil?
+    obj.events.remove self
+    Inform::Events.active_objects.remove obj if obj.events.empty?
+  end
+
+  def cancelled
+    successors.each(&:on_cancelled_antecedent)
+  rescue StandardError => e
+    log.error "Error cancelling #{self}: #{e.message}", e
+  ensure
+    deactivate cause
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  def completed
+    semaphore.synchronize { self.concluded = true }
+    return if !antecedent.nil? && antecedent.cancelled? && terminus.nil?
+    return if cancelled? && terminus.nil?
+    successors.each { |event| schedule event }
+  rescue StandardError => e
+    log.error "Error completing #{self}: #{e.message}", e
+  ensure
+    deactivate cause
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+end
+# module PrivateEventMethods
+
+# The EventInitializationMethods module
+module EventInitializationMethods
+  include EventConstants
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def init_fields(params, &block)
+    @successors = defined?(Java) ? java.util.concurrent.CopyOnWriteArrayList.new : []
+    @time = Time.ms
+    @cause = params[:cause]
+    @name = params.fetch(:name, format(EventNameTemplate, time: @time))
+    @args = params[:args]
+    # Converting a given block to a lambda supposedly enables the use of return
+    # statements inside the event activity blocks.
+    # TODO: Cite documentation source.
+    # TODO: Implement tests.
+    # TODO: Verify this change prevents the error:
+    # Event block used return keyword: unexpected return
+    @activity = params.fetch(:activity, block_given? ? block.to_lambda : @name)
+    @antecedent = params[:antecedent]
+    @time_delay = params.fetch(:delay, 0)
+    @terminus = params[:terminus] ? self : nil
+    @type = params.fetch(:type, :integral)
+    @when = params.fetch(:when, :eventually)
+    @callstack = caller.slice((%i[immediately elementally].include?(@when) ? 4 : 3)..-1)
+    @concluded = false
+    # @cause = @cause.player if @cause.is_a? InformLibrary # TODO: Test
+    @identity = generate_identity
+    @context = params[:context]
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def generate_identity
+    s = format(EventCauseIdentityTemplate, identity: @cause.identity, name: @cause.name)
+    if !@callstack.empty?
+      trace = @callstack.first.gsub(Inform::Runtime.project_dir_path, '')
+      location, line_number, method_name = CallerPattern.match(trace)&.captures
+      s << format(EventSourceFullTemplate,
+        method_name: method_name, source_location: location, source_line_number: line_number)
+    elsif @activity.respond_to?(:source_location) || @activity.is_a?(Proc)
+      activity_source_location_enumerator = @activity.source_location.each
+      source_location = activity_source_location_enumerator.next.gsub(Inform::Runtime.project_dir_path, '')
+      source_line_number = activity_source_location_enumerator.next
+      s << format(
+        EventSourceTemplate, source_location: source_location, source_line_number: source_line_number)
+    elsif name != @activity.to_s
+      s << format(EventActivityTemplate, activity: @activity)
+    end
+    s << format(EventAntecedantTemplate, antecedent: @antecedent) unless @antecedent.nil?
+    s
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+
+  def init_context(context, antecedent, cause)
+    return contextualize(context) unless context.nil?
+    if antecedent&.cause.respond_to?(:inflib)
+      return contextualize(antecedent.cause.inflib) unless antecedent&.cause&.inflib.nil?
+    end
+    contextualize(cause) unless cause.nil? # TODO: Maybe remove
+  end
+
+  def defer(event)
+    event.antecedent << event
+  end
+
+  def schedule_or_defer(event)
+    return defer(event) if !event.antecedent.nil? && !event.antecedent.concluded?
+    schedule(event) if event.antecedent.nil? || event.antecedent.cancelled?
+  end
+end
+# module EventInitializationMethods
+
+# The Inform module
+module Inform
+  # The Inform::Event class
+  class Event
+    include PublicEventMethods
+    include PrivateEventMethods
+
+    attr_reader :cause, :time, :time_delay, :name, :args, :type, :context,
+      :activity, :terminus, :semaphore, :identity
+    attr_accessor :antecedent, :successors, :future, :concluded, :callstack
+
+    def initialize(params = {}, &block)
+      @semaphore = Mutex.new
+      init_fields(params, &block)
+      init_context(@context, @antecedent, @cause)
+      invoke(self)
+    end
+
+    private
+
+    include EventInitializationMethods
+  end
+
+  # The Inform::Events module
+  module Events
+    REGISTRY = Struct.new(:memo).new({})
+    THREADS_PER_PROCESSOR = 10
+
+    def active_objects
+      @active_objects ||= defined?(Java) ? java.util.concurrent.ConcurrentLinkedQueue.new : []
+    end
+    module_function :active_objects
+
+    def possibilities
+      @possibilities ||= defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {}
+    end
+    module_function :possibilities
+
+    def object_events
+      Inform::Events.possibilities[identity] ||=
+        defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {}
+      Inform::Events.possibilities[identity]
+    end
+    module_function :object_events
+
+    def events(klass = Inform::Event)
+      object_events[klass] ||= defined?(ConcurrentLinkedQueue) ? ConcurrentLinkedQueue.new : []
+    end
+
+    def each(event_class = Inform::Event, &block)
+      events[event_class].each { |event| block.call(event) } if block_given?
+    end
+    module_function :each
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    def available_processors
+      return java.lang.Runtime.runtime.available_processors if defined?(Java)
+      case RbConfig::CONFIG['host_os']
+      when /darwin9/
+        if File.exist?(`which hwprefs`)
+          `hwprefs cpu_count`.strip.to_i
+        else
+          # Better than nothing
+          require 'etc'
+          Etc.nprocessors
+        end
+      when /darwin/
+        if File.exist?(`which hwprefs`)
+          `hwprefs thread_count`.strip.to_i
+        else
+          `sysctl -n hw.ncpu`.strip.to_i
+        end
+      when /linux/
+         `grep -c processor /proc/cpuinfo`.strip.to_i
+      when /freebsd/
+        `sysctl -n hw.ncpu`.strip.to_i
+      when /mswin|mingw/
+        require 'win32ole'
+        cpu = WIN32OLE.connect("winmgmts://").ExecQuery("select NumberOfCores from Win32_Processor")
+        cpu.to_enum.first.NumberOfCores
+      else
+        # Better than nothing
+        require 'etc'
+        Etc.nprocessors
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    module_function :available_processors
+
+    def scheduled_executor
+      REGISTRY.memo[:scheduled_executor] ||=
+        defined?(Java) ? init_java_scheduled_executor : init_scheduled_executor
+    end
+    module_function :scheduled_executor
+
+    def init_scheduled_executor
+      # TODO: Implement
+      # require 'ruby-concurrency'
+      # Concurrent::ScheduledThreadPoolExecutor.new(available_processors * THREADS_PER_PROCESSOR)
+    end
+    module_function :init_scheduled_executor
+
+    def init_java_scheduled_executor
+      executor = java.util.concurrent.Executors.newScheduledThreadPool(
+        available_processors * THREADS_PER_PROCESSOR)
+      executor.setRemoveOnCancelPolicy(true)
+      executor
+    end
+    module_function :init_java_scheduled_executor
+
+    def pooled_executor
+      REGISTRY.memo[:pooled_executor] ||=
+        defined?(Java) ? init_java_pooled_executor : init_pooled_executor
+    end
+    module_function :pooled_executor
+
+    def init_java_pooled_executor
+      Executors.newFixedThreadPool(available_processors * THREADS_PER_PROCESSOR)
+    end
+    module_function :init_java_pooled_executor
+
+    def scheduler
+      REGISTRY.memo[:scheduler] ||=
+        defined?(Java) ? init_java_scheduler : init_scheduler
+    end
+    module_function :scheduler
+
+    def init_scheduler
+      # TODO: Implement
+      # require 'ruby-concurrency'
+      # Concurrent::ThreadPoolExecutor.new(available_processors * THREADS_PER_PROCESSOR)
+    end
+    module_function :init_scheduler
+
+    def init_java_scheduler
+      com.google.common.util.concurrent.MoreExecutors.listeningDecorator(ScheduledExecutor)
+    end
+    module_function :init_java_scheduler
+
+    def pool
+      REGISTRY.memo[:pool] ||= defined?(Java) ? init_java_pool : init_pool
+    end
+    module_function :pool
+
+    def init_pool
+      # TODO: Implement
+      # require 'ruby-concurrency'
+      # Concurrent::ThreadPoolExecutor.new(available_processors * THREADS_PER_PROCESSOR)
+    end
+    module_function :init_pool
+
+    def init_java_pool
+      com.google.common.util.concurrent.MoreExecutors.listeningDecorator(pooled_executor)
+    end
+    module_function :init_java_pool
+  end
+  # module Events
+end
+# module Inform
+
+# The Inform module
+module Inform
+  # The Inform::Events module
+  module Events
+    DEFAULT_ADD_EVENT_PARAMS = { delay: 0 }.freeze
+
+    def register_callback(ctx, *args, &callback)
+      e = Thread.current[:event]
+      return true if e.nil?
+      e.chain({ context: ctx, args: args }, &callback)
+      true
+    end
+
+    def add_event(params = {}, event_params = { cause: self }, &block)
+      if (e = Thread.current[:event]).nil?
+        params = { command: params } unless params.respond_to?(:merge)
+        event_params[:name] = params.delete(:command) if params.include?(:command)
+        Inform::Event.new(event_params.merge(params), &block)
+      else
+        event_params[:name] = params.delete(:command) if params.include?(:command)
+        e.chain(event_params.merge(DEFAULT_ADD_EVENT_PARAMS.merge(event_params)), &block)
+      end
+    end
+    alias eventually add_event
+    alias later add_event
+    alias queue add_event
+    alias enqueue add_event
+
+    # TODO: Figure out a way to determine if an existing event is
+    # already finished.  That is, find a way to implicitly
+    # determine if any existing event is in the react_after phase
+    # instead of the react_before phase.
+    def event(params = {}, &block)
+      params = { command: params } unless params.respond_to?(:merge)
+      event_params = { cause: self }
+      event_params[:name] = params.delete(:command) if params.include?(:command)
+      Inform::Event.new(event_params.merge(params), &block)
+    end
+    alias new_event event
+    alias now event
+    alias react event
+    alias respond event
+
+    def delay(delay, &block)
+      Inform::Event.new({ cause: self, delay: delay }, &block)
+    end
+    alias after_delay delay
+    alias delayed_event delay
+
+    def immediately(ctx, &block)
+      Inform::Event.new({ cause: self, context: ctx, when: :immediately }, &block)
+    end
+
+    def elementally(ctx, &block)
+      Inform::Event.new({ cause: self, context: ctx, type: :elemental, when: :immediately }, &block)
+    end
+
+    def contextualize
+      Thread.current[:event]&.contextualize(self)
+    end
+
+    def active?
+      !events.empty?
+    end
+    alias already_active? active?
+
+    def interrupt(event_class = nil)
+      interruption = Thread.current[:event]
+      Inform::Events.each(event_class) do |event|
+        # Do not artificially terminate the source of an interruption.
+        next if event == interruption
+
+        # Parameterizing Future#cancel with false is supposed to
+        # abort the future without interrupting the executing thread.
+        # Not interrupting the event future's thread may have the
+        # consequence of a variety of data consistency issues.
+        # event.future.cancel false if event != interruption
+
+        # TODO: Test
+        event.future.cancel false
+      end
+      false
+    end
+  end
+  # module Events
+end
+# module Inform