Module: PublicEventMethods

Includes:
EventConstants
Included in:
Inform::Event
Defined in:
lib/story_teller/events.rb

Overview

The PublicEventMethods module

Constant Summary collapse

RecordNotFoundErrorPattern = 
%r{Record not found}.freeze

Constants included from EventConstants

EventConstants::CallerPattern, EventConstants::EventActivityTemplate, EventConstants::EventAntecedantTemplate, EventConstants::EventCauseIdentityTemplate, EventConstants::EventNameTemplate, EventConstants::EventSourceFullTemplate, EventConstants::EventSourceTemplate

Instance Method Summary collapse

Instance Method Details

#<<(event) ⇒ Object 



115
116
117
118
 
# File 'lib/story_teller/events.rb', line 115

def <<(event)
  @successors.add event
  event.antecedent = self
end

#antecedent_cancelled? ⇒ Boolean

Returns:

  • (Boolean) 


147
148
149
150
151
152
153
 
# File 'lib/story_teller/events.rb', line 147

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

#call ⇒ Object

java_signature ‘V call()’



225
226
227
 
# File 'lib/story_teller/events.rb', line 225

def call
  process(self)
end

#call_activity ⇒ Object 



219
220
221
222
 
# File 'lib/story_teller/events.rb', line 219

def call_activity
  return self.activity.call(self) if self.activity.arity == 1
  self.activity.call(*self.args)
end

#cancelled? ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
145
 
# File 'lib/story_teller/events.rb', line 142

def cancelled?
  return true if future.nil?
  future.cancelled?
end

#concluded? ⇒ Boolean

Returns:

  • (Boolean) 


155
156
157
 
# File 'lib/story_teller/events.rb', line 155

def concluded?
  semaphore.synchronize { concluded == true }
end

#contextualize(from) ⇒ Object 



90
91
92
93
94
95
96
 
# File 'lib/story_teller/events.rb', line 90

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

#delay(delay, &block) ⇒ Object Also known as: after_delay

Shortcut for using delays



200
201
202
 
# File 'lib/story_teller/events.rb', line 200

def delay(delay, &block)
  Inform::Event.new({ cause: cause, antecedent: self, delay: delay }, &block)
end

#elemental? ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
 
# File 'lib/story_teller/events.rb', line 130

def elemental?
  @type == :elemental
end

#finally(&block) ⇒ Object Also known as: on_cancel, when_completed, when_done, when_finished, when_over, ultimately 



205
206
207
 
# File 'lib/story_teller/events.rb', line 205

def finally(&block)
  Inform::Event.new({ cause: cause, antecedent: self, terminus: true }, &block)
end

#get ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/story_teller/events.rb', line 159

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

#immediately? ⇒ Boolean

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/story_teller/events.rb', line 138

def immediately?
  @when == :immediately
end

#inspect ⇒ Object 



251
252
253
 
# File 'lib/story_teller/events.rb', line 251

def inspect
  format(EventCauseIdentityTemplate, identity: @cause.identity, name: @cause.name)
end

#integral? ⇒ Boolean

Returns:

  • (Boolean) 


134
135
136
 
# File 'lib/story_teller/events.rb', line 134

def integral?
  @type == :integral
end

#java_get ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/story_teller/events.rb', line 175

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

#mandate_cause_record_exists! ⇒ Object 



257
258
259
260
261
262
263
264
265
 
# File 'lib/story_teller/events.rb', line 257

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

#maybe_log_nilling_warning(callstack) ⇒ Object

TODO: Remove



110
111
112
113
 
# File 'lib/story_teller/events.rb', line 110

def maybe_log_nilling_warning(callstack)
  return if callstack.grep('channel_read')
  ['===========', (caller[-4...] + callstack), '==========='].each { |t| log.warn t unless t.nil? }
end

#now(params = {}, &block) ⇒ Object Also known as: add_event, event, and_then, chain, eventually, later 



187
188
189
190
191
 
# File 'lib/story_teller/events.rb', line 187

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

#on_cancelled_antecedent ⇒ Object 



242
243
244
245
 
# File 'lib/story_teller/events.rb', line 242

def on_cancelled_antecedent
  schedule self unless terminus.nil?
  successors.each(&:on_cancelled_antecedent)
end

#on_failure(_cause) ⇒ Object 



234
235
236
 
# File 'lib/story_teller/events.rb', line 234

def on_failure(_cause)
  cancelled
end

#on_success(_result) ⇒ Object 



238
239
240
 
# File 'lib/story_teller/events.rb', line 238

def on_success(_result)
  completed
end

#origin(x = self) ⇒ Object 



120
121
122
123
 
# File 'lib/story_teller/events.rb', line 120

def origin(x = self)
  x = origin x.antecedent if x.antecedent
  x.object? ? x : x.cause
end

#parse_activity ⇒ Object 



215
216
217
 
# File 'lib/story_teller/events.rb', line 215

def parse_activity
  self.cause.parse(self.activity)
end

#run ⇒ Object

java_signature ‘void run()’



230
231
232
 
# File 'lib/story_teller/events.rb', line 230

def run
  call
end

#termination(x = self) ⇒ Object 



125
126
127
128
 
# File 'lib/story_teller/events.rb', line 125

def termination(x = self)
  event = x.successors.first
  event || x.terminus
end

#to_s ⇒ Object 



247
248
249
 
# File 'lib/story_teller/events.rb', line 247

def to_s
  self.identity
end

#warn_when_nilling_noun(from, to, attribute, value) ⇒ Object

TODO: Remove



99
100
101
102
103
104
105
106
107
 
# File 'lib/story_teller/events.rb', line 99

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