Module: Kernel

Defined in:
lib/story_teller/kernel.rb

Overview

The Kernel module

Defined Under Namespace

Classes: Cache

Constant Summary collapse

Index = 
Cache.new({}, {})
NamespaceDelimiterPattern = 
%r{::}.freeze
JavaPattern = 
%r{java}.freeze
DefineNewRand = 
%(alias :original_rand :rand
def rand(ignore=0)
  %<n>s
end
).freeze
ResetOriginalRand = 
%(alias :rand :original_rand
remove_method :original_rand
).freeze

Instance Method Summary collapse

Instance Method Details

#attempt_twice(&_block) ⇒ Object

rubocop: disable Metrics/MethodLength



134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/story_teller/kernel.rb', line 134

def attempt_twice(&_block)
  tries ||= 2
  return yield
rescue StandardError => e
  tries -= 1
  if tries > 0
    log.warn e.message
    retry
  else
    log.error e
    return nil
  end
end

#Attribute(attribute) ⇒ Object 



38
39
40
 
# File 'lib/story_teller/kernel.rb', line 38

def Attribute(attribute)
  StoryTeller::Library::Directives.Attribute(attribute)
end

#child(obj = nil) ⇒ Object 



306
307
308
309
310
311
 
# File 'lib/story_teller/kernel.rb', line 306

def child(obj = nil)
  return nil if obj.nil?
  return nil unless obj.respond_to?(:child)
  obj.refresh if obj.respond_to?(:refresh)
  obj.child.refresh
end

#children(obj = nil, prop = :@children) ⇒ Object 



345
346
347
348
349
350
351
352
353
354
 
# File 'lib/story_teller/kernel.rb', line 345

def children(obj = nil, prop = :@children)
  return 0 if obj.nil?
  obj.refresh if obj.respond_to?(:refresh)
  if defined? db
  return db.run('SELECT count(id) from "object" where parent_id = ' + obj.id) unless sysobj?
  end
  return obj.instance_variable_get(prop).length if obj.instance_variable_defined?(prop)
  return unless obj.respond_to?(:children)
  obj.children.length
end

#class_loader ⇒ Object

Raises:

  • (NotImplementedError) 


178
179
180
181
182
 
# File 'lib/story_teller/kernel.rb', line 178

def class_loader
  return JRuby.runtime.jruby_class_loader if defined?(JRuby)

  raise NotImplementedError, "class_loader is only available on JRuby"
end

#collect_garbage ⇒ Object

rubocop: disable Metrics/AbcSize



213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'lib/story_teller/kernel.rb', line 213

def collect_garbage
  return unless java?

  java.lang.System.gc()
  sleep 0.1
  java.lang.System.runFinalization()
  sleep 0.1
rescue java.lang.Throwable => e
  log.error "Unexpected java error invoking garbage collection: #{e}", e
rescue StandardError => e
  log.error "Unexpected error invoking garbage collection: #{e}", e
end

#Constant(property, value) ⇒ Object 



50
51
52
 
# File 'lib/story_teller/kernel.rb', line 50

def Constant(property, value)
  StoryTeller::Library::Directives.Constant(property, value)
end

#Default(property, value) ⇒ Object 



46
47
48
 
# File 'lib/story_teller/kernel.rb', line 46

def Default(property, value)
  StoryTeller::Library::Directives.Default(property, value)
end

#destroy(obj = nil) ⇒ Object 



356
357
358
359
360
361
362
 
# File 'lib/story_teller/kernel.rb', line 356

def destroy(obj = nil)
  return if obj.nil?
  return unless obj.respond_to?(:has?)
  return if obj.has? :prized
  return unless obj.respond_to?(:destroy)
  obj.destroy
end

#find_class(class_name) ⇒ Object 



126
127
128
129
130
 
# File 'lib/story_teller/kernel.rb', line 126

def find_class(class_name)
  klass = Index.classes[class_name]
  klass ||= get_constant(class_name)
  Index.classes[class_name] = klass
end

#find_module(module_name) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
 
# File 'lib/story_teller/kernel.rb', line 114

def find_module(module_name)
  module_name = "::#{module_name}" unless NamespaceDelimiterPattern.match?(module_name)
  mod = Index.modules[module_name]
  # TODO: Test
  # return mod if mod.is_a?(Module)

  mod ||= get_constant(module_name)
  return nil if mod.is_a?(Class)
  Index.modules[module_name] = mod
end

#get_constant(constant_name, target = Object) ⇒ Object

rubocop: disable Metrics/MethodLength



94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/story_teller/kernel.rb', line 94

def get_constant(constant_name, target = Object)
  constant = nil
  begin
    constant = target.const_get(constant_name)
  rescue NameError => e
    log.error "Undefined constant #{constant_name}: #{e}", e
  rescue SyntaxError => e
    log.error "Unexpected syntax error getting constant #{constant_name}", e
  rescue StandardError => e
    log.error "Unexpected error getting constant #{constant_name}", e
  end
  constant
end

#give(obj = nil, *attributes) ⇒ Object 



364
365
366
367
368
 
# File 'lib/story_teller/kernel.rb', line 364

def give(obj = nil, *attributes)
  return if obj.nil?
  return unless obj.respond_to?(:tag)
  obj.tag(*attributes)
end

#import_global(symbol) ⇒ Object 



58
59
60
 
# File 'lib/story_teller/kernel.rb', line 58

def import_global(symbol)
  StoryTeller::Library::Directives.import_global(symbol)
end

#Include(inclusion) ⇒ Object 



33
34
35
36
 
# File 'lib/story_teller/kernel.rb', line 33

def Include(inclusion)
  StoryTeller::Engine.main_object = self if inclusion == "Parser"
  StoryTeller::Library::Directives.Include(inclusion)
end

#indent(stack_depth = [0, caller(2).length - 9].max) ⇒ Object 



150
151
152
 
# File 'lib/story_teller/kernel.rb', line 150

def indent(stack_depth = [0, caller(2).length - 9].max)
  '  ' * stack_depth
end

#java? ⇒ Boolean

Returns:

  • (Boolean) 


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

def java?
  JavaPattern.match?(RUBY_PLATFORM)
end

#jump(symbol) ⇒ Object 



280
281
282
 
# File 'lib/story_teller/kernel.rb', line 280

def jump(symbol)
  throw symbol
end

#kneel(obj) ⇒ Object 



407
408
409
410
411
 
# File 'lib/story_teller/kernel.rb', line 407

def kneel(obj)
  give obj, :kneeling unless obj.has? :kneeling
  take obj, :sitting
  take obj, :prone
end

#label(symbol, &_block) ⇒ Object 



270
271
272
273
274
275
276
277
 
# File 'lib/story_teller/kernel.rb', line 270

def label(symbol, &_block)
  loop do
    catch symbol do
      yield
      break
    end
  end
end

#Link(link) ⇒ Object 



54
55
56
 
# File 'lib/story_teller/kernel.rb', line 54

def Link(link)
  StoryTeller::Library::Directives.Link(link)
end

#load_service ⇒ Object

Raises:

  • (NotImplementedError) 


185
186
187
188
189
 
# File 'lib/story_teller/kernel.rb', line 185

def load_service
  return JRuby.runtime.load_service if defined?(JRuby)

  raise NotImplementedError, "load_service is only available on JRuby"
end

#memory_usage ⇒ Object 



205
206
207
208
209
 
# File 'lib/story_teller/kernel.rb', line 205

def memory_usage
  total_memory = java.lang.Runtime.getRuntime().totalMemory()
  free_memory = java.lang.Runtime.getRuntime().freeMemory()
  total_memory - free_memory
end

#metaclass(obj) ⇒ Object 



244
245
246
 
# File 'lib/story_teller/kernel.rb', line 244

def metaclass(obj)
  obj.class.metaclass
end

#move(obj, new_parent) ⇒ Object

rubocop: disable Metrics/AbcSize rubocop: disable Metrics/CyclomaticComplexity rubocop: disable Metrics/PerceivedComplexity

Raises:

  • (CycleError) 


379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/story_teller/kernel.rb', line 379

def move(obj, new_parent)
  return if obj.nil?
  return unless new_parent.respond_to?(:<<)
  return unless new_parent.respond_to?(:in?)
  new_parent.safe_refresh if new_parent.respond_to?(:safe_refresh)
  obj.safe_refresh if obj.respond_to?(:safe_refresh)
  raise CycleError if new_parent.in? obj
  obj.remove if obj.respond_to?(:remove)
  new_parent << obj
  obj.safe_refresh if obj.respond_to?(:safe_refresh)
  new_parent.safe_refresh if new_parent.respond_to?(:safe_refresh)
end

#object_space ⇒ Object

Raises:

  • (NotImplementedError) 


192
193
194
195
196
 
# File 'lib/story_teller/kernel.rb', line 192

def object_space
  return JRuby.runtime.object_space if defined?(JRuby)

  raise NotImplementedError, "object_space is only available on JRuby"
end

#override(replacement, method_name) ⇒ Object 



285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/story_teller/kernel.rb', line 285

def override(replacement, method_name)
  new_method = nil
  begin
    old_method = self.instance_method(method_name)
    remove_method(method_name) if old_method.arity > 0
    new_method = define_method(replacement.to_s, old_method)
  rescue NameError => e
    log.error "Error overriding method #{method_name}: #{e}", e
  end
  new_method
end

#parent(obj = nil, prop = :@parent, &block) ⇒ Object

rubocop: disable Metrics/CyclomaticComplexity rubocop: disable Metrics/PerceivedComplexity



324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/story_teller/kernel.rb', line 324

def parent(obj = nil, prop = :@parent, &block)
  return nil if obj.nil?
  obj.refresh if obj.respond_to?(:refresh)
  obj_parent = nil
  obj_parent = select_parent(obj, &block) if block_given?
  obj_parent ||= obj.instance_variable_get(prop) if obj.instance_variable_defined?(prop)
  obj_parent ||= obj.parent if obj.respond_to?(:parent)
  return nil if obj_parent.nil?
  obj_parent.refresh if obj_parent.respond_to?(:refresh)
  obj_parent
end

#parent_selector(obj, &block) ⇒ Object 



313
314
315
316
317
318
319
320
 
# File 'lib/story_teller/kernel.rb', line 313

def parent_selector(obj, &block)
  return nil if obj.nil?
  loop do
    obj = obj.parent
    break if block.call(obj)
  end
  obj
end

#Property(property_or_modifier, modifier = nil, value = nil) ⇒ Object 



42
43
44
 
# File 'lib/story_teller/kernel.rb', line 42

def Property(property_or_modifier, modifier = nil, value = nil)
  StoryTeller::Library::Directives.Property(property_or_modifier, modifier, value)
end

#recline(obj) ⇒ Object 



413
414
415
416
417
 
# File 'lib/story_teller/kernel.rb', line 413

def recline(obj)
  give obj, :prone unless obj.has? :prone
  take obj, :sitting
  take obj, :kneeling
end

#reload_feature(feature) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
 
# File 'lib/story_teller/kernel.rb', line 166

def reload_feature(feature)
  silence_warnings do
    # Remove a loaded feature:
    load_service.remove_internal_loaded_feature(feature)
    # Supposedly, purge old compiled script code:
    reset_runtime
    # Reload the feature:
    load_service.load(feature, true)
  end
end

#reset_constant(constant, value, target = Object) ⇒ Object 



68
69
70
71
72
73
74
75
76
 
# File 'lib/story_teller/kernel.rb', line 68

def reset_constant(constant, value, target = Object)
  return if constant.nil?
  silence_warnings do
    target.instance_eval { const_set(constant.to_sym, value) }
  end
rescue StandardError => e
  log.error "Unexpected error resetting constant #{constant}", e
  nil
end

#reset_runtime ⇒ Object

rubocop: disable Metrics/AbcSize



156
157
158
159
160
161
162
 
# File 'lib/story_teller/kernel.rb', line 156

def reset_runtime
  org.jruby.Ruby.new_instance().use_as_global_runtime()
  engine = javax.script.ScriptEngineManager.new().get_engine_by_name('jruby')
  # rubocop: disable Style/RedundantInterpolation
  log.warn "#{(engine.methods - Object.instance_methods).uniq.sort.inspect}"
  # rubocop: enable Style/RedundantInterpolation
end

#return_after(*args, &block) ⇒ Object 



62
63
64
65
 
# File 'lib/story_teller/kernel.rb', line 62

def return_after(*args, &block)
  block.call
  args.first
end

#setrandom(n) ⇒ Object 



258
259
260
261
262
263
264
265
266
267
 
# File 'lib/story_teller/kernel.rb', line 258

def setrandom(n)
  puts "--------------------" # TODO: Remove
  puts "Before setrandom Kernel.respond_to?(:original_rand) #{Kernel.respond_to?(:original_rand)}" # TODO: Remove
  code = ResetOriginalRand if Kernel.respond_to?(:original_rand)
  code ||= format(DefineNewRand, n: n)
  log.debug "code:\n#{code}" # TODO: Remove
  Kernel.module_eval(code)
ensure
  puts "After setrandom Kernel.respond_to?(:original_rand) #{Kernel.respond_to?(:original_rand)}"
end

#sibling(obj = nil) ⇒ Object

rubocop: enable Metrics/CyclomaticComplexity rubocop: enable Metrics/PerceivedComplexity



338
339
340
341
342
343
 
# File 'lib/story_teller/kernel.rb', line 338

def sibling(obj = nil)
  return nil if obj.nil?
  return nil unless obj.respond_to?(:sibling)
  obj.refresh if obj.respond_to?(:refresh)
  obj.sibling.refresh
end

#silence_warnings(&_block) ⇒ Object 



298
299
300
301
302
303
304
 
# File 'lib/story_teller/kernel.rb', line 298

def silence_warnings(&_block)
  old_verbose = $VERBOSE
  $VERBOSE = nil
  yield
ensure
  $VERBOSE = old_verbose
end

#sit(obj) ⇒ Object 



401
402
403
404
405
 
# File 'lib/story_teller/kernel.rb', line 401

def sit(obj)
  give obj, :sitting unless obj.has? :sitting
  take obj, :kneeling
  take obj, :prone
end

#stand(obj) ⇒ Object

rubocop: enable Metrics/AbcSize rubocop: enable Metrics/CyclomaticComplexity rubocop: enable Metrics/PerceivedComplexity



395
396
397
398
399
 
# File 'lib/story_teller/kernel.rb', line 395

def stand(obj)
  take obj, :sitting
  take obj, :kneeling
  take obj, :prone
end

#take(obj = nil, *attributes) ⇒ Object 



370
371
372
373
374
 
# File 'lib/story_teller/kernel.rb', line 370

def take(obj = nil, *attributes)
  return if obj.nil?
  return unless obj.respond_to?(:untag)
  obj.untag(*attributes)
end

#toggle_constant(constant, target = ::Object) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/story_teller/kernel.rb', line 79

def toggle_constant(constant, target = ::Object)
  silence_warnings do
    if target.const_defined?(constant)
      target.instance_eval { remove_const(constant) }
    else
      target.instance_eval { const_set(constant, true) }
    end
  end
rescue StandardError => e
  log.error "Unexpected error toggling constant #{constant}", e
  nil
end