inform-runtime 1.0.4

data/lib/runtime/kernel.rb

@@ -0,0 +1,450 @@
+# 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/>.
+
+# Define a class inheriting from StandardError to raise when
+# a method is already defined
+class MethodAlreadyDefined < StandardError
+  ERROR_MESSAGE = 'Method %<method_name>s already defined'.freeze
+  def initialize(method_name)
+    super(format(ERROR_MESSAGE, method_name: method_name))
+  end
+end
+
+# The Kernel module
+module Kernel
+  def import_global(symbol)
+    Inform::Runtime.import_global(symbol)
+  end
+
+  def Link(link)
+    Inform::Runtime.Link(link)
+  end
+
+  def Include(inclusion)
+    Inform::Runtime.instance.main_object = self if inclusion == "Parser"
+    Inform::Runtime.Include(inclusion)
+  end
+
+  def Attribute(attribute)
+    Inform::Runtime.Attribute(attribute)
+  end
+
+  def Property(property_or_modifier, modifier = nil, value = nil)
+    Inform::Runtime.Property(property_or_modifier, modifier, value)
+  end
+
+  def Default(property, value)
+    Inform::Runtime.Default(property, value)
+  end
+
+  def Constant(property, value)
+    Inform::Runtime.Constant(property, value)
+  end
+
+  # TODO: Remove
+  # def with(context = nil, &block)
+  #   if context.nil?
+  #     self.instance_eval(&block)
+  #   else
+  #     self.instance_exec(context, &block)
+  #   end
+  #   self.save if self.respond_to?(:save)
+  #   self
+  # end
+
+  def return_after(*args, &block)
+    block.call
+    args.first
+  end
+
+  raise MethodAlreadyDefined, :reset_constant if respond_to?(:reset_constant)
+  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
+
+  raise MethodAlreadyDefined, :toggle_constant if respond_to?(:toggle_constant)
+  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
+
+  raise MethodAlreadyDefined, :get_constant if respond_to?(:get_constant)
+  # rubocop: disable Metrics/MethodLength
+  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
+  # rubocop: enable Metrics/MethodLength
+
+  Cache = Struct.new(:classes, :modules)
+  Index = Cache.new({}, {})
+  NamespaceDelimiterPattern = %r{::}.freeze
+
+  raise MethodAlreadyDefined, :find_module if respond_to?(:find_module)
+  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
+
+  raise MethodAlreadyDefined, :find_class if respond_to?(:find_class)
+  def find_class(class_name)
+    klass = Index.classes[class_name]
+    klass ||= get_constant(class_name)
+    Index.classes[class_name] = klass
+  end
+
+  raise MethodAlreadyDefined, :attempt_twice if respond_to?(:attempt_twice)
+  # rubocop: disable Metrics/MethodLength
+  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
+  # rubocop: enable Metrics/MethodLength
+
+  raise MethodAlreadyDefined, :indent if respond_to?(:indent)
+  def indent(stack_depth = [0, caller(2).length - 9].max)
+    '  ' * stack_depth
+  end
+
+  raise MethodAlreadyDefined, :reset_runtime if respond_to?(:reset_runtime)
+  # rubocop: disable Metrics/AbcSize
+  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
+  # rubocop: enable Metrics/AbcSize
+
+  raise MethodAlreadyDefined, :reload_feature if respond_to?(:reload_feature)
+  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
+
+  raise MethodAlreadyDefined, :class_loader if respond_to?(:class_loader)
+  def class_loader
+    JRuby.runtime.jruby_class_loader
+  end
+
+  raise MethodAlreadyDefined, :load_service if respond_to?(:load_service)
+  def load_service
+    JRuby.runtime.load_service
+  end
+
+  raise MethodAlreadyDefined, :object_space if respond_to?(:object_space)
+  def object_space
+    JRuby.runtime.object_space
+  end
+
+  JavaPattern = %r{java}.freeze
+
+  def java?
+    JavaPattern.match?(RUBY_PLATFORM)
+  end
+
+  raise MethodAlreadyDefined, :memory_usage if respond_to?(:memory_usage)
+  def memory_usage
+    total_memory = java.lang.Runtime.getRuntime().totalMemory()
+    free_memory = java.lang.Runtime.getRuntime().freeMemory()
+    total_memory - free_memory
+  end
+
+  raise MethodAlreadyDefined, :collect_garbage if respond_to?(:collect_garbage)
+  # rubocop: disable Metrics/AbcSize
+  def collect_garbage
+    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
+  # rubocop: enable Metrics/AbcSize
+
+  # Additional Inform-specific standard library routines
+  # TODO: externalize in another module
+  # The only reason these are included here is to ensure system-wide
+  # availability.  If ubiquitous availability can be assured upon
+  # relocation, then proceed.
+  #
+  # TODO: Why on earth doesn't Inform::Object instances seem to
+  # inherit the built-in methods defined in the Inform module?
+  #
+  #     module Inform
+  #       class Object
+  #         include Inform
+  #
+  # So when Spell < Inform::Object, for instance, why isn't the
+  # method Inform::light_adjusted(...) available?
+
+  raise MethodAlreadyDefined, :metaclass if respond_to?(:metaclass)
+  def metaclass(obj)
+    obj.class.metaclass
+  end
+
+  DefineNewRand = %(alias :original_rand :rand
+def rand(ignore=0)
+  %<n>s
+end
+).freeze
+  ResetOriginalRand = %(alias :rand :original_rand
+remove_method :original_rand
+).freeze
+
+  raise MethodAlreadyDefined, :setrandom if respond_to?(:setrandom)
+  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
+
+  raise MethodAlreadyDefined, :label if respond_to?(:label)
+  def label(symbol, &_block)
+    loop do
+      catch symbol do
+        yield
+        break
+      end
+    end
+  end
+
+  raise MethodAlreadyDefined, :jump if respond_to?(:jump)
+  def jump(symbol)
+    throw symbol
+  end
+
+  raise MethodAlreadyDefined, :override if respond_to?(:override)
+  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
+
+  raise MethodAlreadyDefined, :silence_warnings if respond_to?(:silence_warnings)
+  def silence_warnings(&_block)
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  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
+
+  def parent_selector(obj, &block)
+    return nil if obj.nil?
+    loop do
+      obj = obj.parent
+      break if block.call(obj)
+    end
+    obj
+  end
+
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/PerceivedComplexity
+  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
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/PerceivedComplexity
+
+  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
+
+  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
+
+  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
+
+  def give(obj = nil, *attributes)
+    return if obj.nil?
+    return unless obj.respond_to?(:tag)
+    obj.tag(*attributes)
+  end
+
+  def take(obj = nil, *attributes)
+    return if obj.nil?
+    return unless obj.respond_to?(:untag)
+    obj.untag(*attributes)
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/PerceivedComplexity
+  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
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/PerceivedComplexity
+
+  def stand(obj)
+    take obj, :sitting
+    take obj, :kneeling
+    take obj, :prone
+  end
+
+  def sit(obj)
+    give obj, :sitting unless obj.has? :sitting
+    take obj, :kneeling
+    take obj, :prone
+  end
+
+  def kneel(obj)
+    give obj, :kneeling unless obj.has? :kneeling
+    take obj, :sitting
+    take obj, :prone
+  end
+
+  def recline(obj)
+    give obj, :prone unless obj.has? :prone
+    take obj, :sitting
+    take obj, :kneeling
+  end
+end
+# module Kernel
+
+# The ObjectSpace module
+module ObjectSpace
+  def self.enabled?
+    ObjectSpace.respond_to?(:each_object) && ObjectSpace.each_object {} # rubocop: disable Lint/EmptyBlock
+    true
+  rescue StandardError => e
+    log.debug "Error accessing object space: #{e.message}"
+    false
+  end
+end
+
+if defined?(Java)
+  JavaStackTracePattern = %r{(org[/.]+(java|jruby)|method_missing)}.freeze
+
+  # The Java module
+  module Java
+    # The Java::JavaLang module
+    module JavaLang
+      # The Java::JavaLang::Throwable class
+      class Throwable
+        def backtrace
+          self.getStackTrace().map(&:to_s).grep_v(JavaStackTracePattern)
+        end
+      end
+    end
+  end
+end
+# defined?(Java)

data/lib/runtime/library.rb

@@ -0,0 +1,59 @@
+# 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/>.
+
+require_relative 'library_loader'
+
+# The Inform module
+module Inform
+  # The Library module
+  module Library
+    @methods_index = []
+
+    def methods_index
+      return @methods_index unless @methods_index.empty?
+      load_library_methods
+      @methods_index
+    end
+    module_function :methods_index
+
+    private
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def load_library_methods
+      library_methods = Set.new
+      library_methods.merge(StdLib.instance_methods(false))
+      library_methods.merge(Inform::IO.instance_methods(false))
+      library_methods.merge(Inform.instance_methods(false))
+      library_methods.merge(InformLibrary.instance_methods(false))
+      Inform.included_modules.each do |mod|
+        library_methods.merge(mod.instance_methods(false))
+      end
+      InformLibrary.included_modules.each do |mod|
+        library_methods.merge(mod.instance_methods(false))
+      end
+      @methods_index.concat(library_methods.to_a).sort
+      log.debug "Loaded library methods: #{@methods_index}"
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+    module_function :load_library_methods
+  end
+end

data/lib/runtime/library_loader.rb

@@ -0,0 +1,135 @@
+# 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/>.
+
+require 'set'
+
+# The Inform module
+module Inform
+  # The Inform::Library module
+  module Library
+    GEM_NAME = 'inform6lib'.freeze
+    GEM_PATH = Gem.loaded_specs[GEM_NAME]&.full_gem_path or raise "The #{GEM_NAME} gem is required"
+
+    DeclaredProperties = Struct.new(:memo).new({})
+    DeclaredAttributes = Struct.new(:memo).new(Set.new)
+    DeclaredGlobals = Struct.new(:memo).new([])
+    class LibraryLoadError < StandardError; end
+
+    def self.inform_gem_lib_path
+      @inform_gem_lib_path ||= File.expand_path(File.join(Inform::Library::GEM_PATH, 'lib'))
+    end
+
+    # The Library::Loader module provides methods for loading Library files.
+    module Loader
+      def load_library
+        overrides
+      end
+
+      def overrides
+        InformLibrary.extend(Inform::RuntimeLibrary)
+        manage_inform_library
+      end
+    end
+
+    # The Inform::Library::ClassMethods module
+    module ClassMethods
+      def Link(link)
+        # TODO: Implement
+        # Not a priority, because in the original Inform6 links were
+        # effectively just pointers to objects loaded in memory, and
+        # weren't persisted using a database relation.
+      end
+
+      InclusionGrammarGuessTemplate = '%<inclusion>s.h.inf.rb'.freeze
+      InclusionGuessesTemplate = '%<inclusion>s.h'.freeze
+
+      def Include(inclusion)
+        inclusion = Inform::Runtime.language_name if /^language__$/.match(inclusion)
+        grammar_guess = format(InclusionGrammarGuessTemplate, inclusion: inclusion)
+        guess = File.expand_path(
+          File.join(
+            Inform::Library.inform_gem_lib_path,
+            Inform::Runtime.inform_dir_path,
+            grammar_guess))
+        return Inform.load_grammar_by_path(guess) if File.exist?(guess)
+        require_first_existing(format(InclusionGuessesTemplate, inclusion: inclusion).split)
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/MethodLength
+      def require_first_existing(guesses)
+        guessed_file_path = File.join(Inform::Runtime.inform_dir_path, guesses.shift)
+        guessed_local_file_path = File.expand_path(guessed_file_path)
+        if File.exist?(guessed_local_file_path)
+          log.debug "Loading local library file: #{guessed_local_file_path}"
+          require_relative guessed_local_file_path
+        else
+          log.debug "Loading library: #{guessed_local_file_path}"
+          require guessed_file_path
+        end
+      rescue LoadError, StandardError => e
+        log.warn e.message
+        e.backtrace.each { |t| log.warn t } if defined?(Logging)
+        retry unless guesses.empty?
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/MethodLength
+
+      def Attribute(attribute)
+        DeclaredAttributes.memo << attribute
+      end
+
+      def declare_property(property, value, _modifier = nil)
+        DeclaredProperties.memo[property] ||= []
+        DeclaredProperties.memo[property] << value
+      end
+
+      PropertyModifiers = %i[additive].freeze
+      def Property(*args)
+        if PropertyModifiers.include?(modifier_or_property = args.shift)
+          declare_property(args.shift, args.shift, modifier_or_property)
+        else
+          declare_property(modifier_or_property, args.shift)
+        end
+      end
+
+      def Default(property, value)
+        Constant(property, value)
+      end
+
+      def 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
+
+      def import_global(symbol)
+        DeclaredGlobals.memo << symbol
+      end
+    end
+    # module ClassMethods
+  end
+  # module Library
+end
+# module Inform