inform-runtime 1.0.4

data/lib/runtime/runtime.rb

@@ -0,0 +1,321 @@
+# 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 'config'
+require_relative 'game'
+require_relative 'session'
+require_relative 'io'
+require_relative 'context'
+require_relative 'library'
+require_relative 'options'
+require_relative 'publication'
+
+# The Inform module
+module Inform
+  # The RuntimeConstants module
+  module RuntimeConstants
+    UndefinedMainPattern = %r{undefined method 'Main' for an instance of Object}.freeze
+    Registry = Class.new(Hash)
+    LibraryRegistry = Registry.new
+  end
+
+  # The RuntimeLibrary module
+  module RuntimeLibrary
+    def play
+      log.debug "Using runtime-managed InformLibrary play method override"
+      inform_library = Inform::Runtime.libraries[Inform::Runtime]
+      inform_library.play
+      inform_library
+    end
+  end
+
+  # The RuntimeClassMethods module
+  module RuntimeClassMethods
+    def libraries
+      Inform::Runtime::LibraryRegistry
+    end
+
+    def default_config
+      @default_config ||= Inform::Config::DEFAULTS
+    end
+
+    def default_game_dir_path
+      File.join(project_dir_path, Inform::Runtime.default_config[:game_dir_name])
+    end
+
+    def support_dir_path
+      Inform::SUPPORT_DIR_PATH
+    end
+
+    def inform_dir_path
+      Inform::INFORM_DIR_PATH
+    end
+
+    def lib_dir_path
+      Inform::LIB_DIR_PATH
+    end
+
+    def project_dir_path
+      Inform::PROJECT_DIR_PATH
+    end
+
+    def database_saves_dir_path
+      File.join(Inform::Runtime.project_dir_path, '.' + Inform::Game.config[:database_name] + '_saves')
+    end
+
+    def default_environment
+      Inform::Runtime.default_config[:environment]
+    end
+
+    def invocation_properties
+      return Inform::Runtime.instance.invocation_properties unless Inform::Runtime.instance.nil?
+      Inform::Runtime.default_config.fetch(:properties, '').split.map(&:to_sym)
+    end
+
+    def invocation_context
+      return Inform::Runtime.instance.invocation_context unless Inform::Runtime.instance.nil?
+      Struct.new(*Inform::Runtime.invocation_properties)
+    end
+
+    def language_name
+      Inform::Runtime.default_config[:language]
+    end
+
+    def main_gem_spec_executable
+      require 'rubygems'
+      current_working_dir = File.expand_path(__dir__)
+      gem_spec = Gem.loaded_specs.values.find do |s|
+        current_working_dir.start_with?(s.full_gem_path)
+      end
+      (gem_spec&.executables || []).first
+    end
+
+    def player?(obj)
+      return false unless defined?(Inform::IO::Session) && Inform::IO::Session.respond_to?(:players)
+      Inform::IO::Session.players.include?(obj)
+    end
+
+    def init(options = Inform::Runtime.default_config)
+      Inform::Runtime.instance(options)
+    end
+
+    def instance(options = Inform::Runtime.default_config)
+      return @instance unless @instance.nil?
+      @instance_mutex.synchronize do
+        @instance ||= new(options)
+      end
+      @instance
+    end
+  end
+  # module RuntimeClassMethods
+
+  # The RuntimeInstanceMethods module
+  module RuntimeInstanceMethods
+    include RuntimeConstants
+
+    attr_accessor :main_object
+
+    def config_file_path
+      @config_file_path ||= File.join(game_path, @options[:game_config_file_name])
+    end
+
+    def game_dir_name
+      @game_dir_name ||= @options[:game_dir_name]
+    end
+
+    def game_path
+      @game_path ||= File.expand_path(@options[:game_path])
+    end
+
+    def game_components
+      @game_components ||= @options.fetch(:game_components, '').split.map(&:to_sym)
+    end
+
+    def grammar_module_path
+      @grammar_module_path ||= File.join(game_path, @options[:game_grammar_module_name])
+    end
+
+    def invocation_properties
+      @invocation_properties ||= @options.fetch(:properties, '').split.map(&:to_sym)
+    end
+
+    def invocation_context
+      @invocation_context ||= Struct.new(*invocation_properties)
+    end
+
+    def invoke_main_method
+      ::Object.new.send(:Main)
+    rescue NameError => e
+      if UndefinedMainPattern.match?(e.message)
+        log.error "Main() definition is missing"
+      else
+        log.error e.message
+        e.backtrace.each { |t| log.error t } # TODO: Remove
+      end
+    end
+
+    # TODO: Ensuring the location of the player object requires
+    # that this method be invoked before the move @player, @location
+    # operation in the InformLibrary#play method.  This means that
+    # ensuring the location must take place either in the game-
+    # defined Initialise() method, or else it can happen in a
+    # provided LibraryExtension method, but in that case it would
+    # be at risk of being overridden by a game-defined Initialise()
+    # method.
+    # TODO: Try to figure out what the best approach here is.  I
+    # think that if a multi-player game is to supply an entrypoint
+    # module, it will have to handle the location ensurance itself.
+    def ensure_location
+      return if inform_library.nil?
+      return if inform_library.location
+      player_obj = inform_library.player
+      location = player_obj.location
+      location ||= player_obj.spawn_point if player_obj.respond_to?(:spawn_point)
+      inform_library.location = location
+    end
+
+    def inform_library(key = Inform::Runtime)
+      Inform::Runtime.libraries[key]
+    end
+
+    def manage_inform_library(key = Inform::Runtime)
+      Inform::Runtime.libraries[key] ||= begin
+        inform_library = InformLibrary.new
+        if self.respond_to?(:specialized_player)
+          inform_library.selfobj = specialized_player
+        end
+        inform_library.subscribe(inform_library.selfobj)
+        inform_library
+      end
+    end
+
+    def apply_preferences
+      return if inform_library.nil?
+      player_obj = inform_library.player
+      preferences = player_obj.&:preferences
+      return if preferences.nil? || !preferences.respond_to?(:properties)
+      preferences.properties.each_pair do |key, value|
+        variable = :"@#{key}"
+        Parser.initial_state.delete(variable)
+        inform_library.instance_variable_set(variable, value)
+      end
+    end
+
+    def manage_privileges
+      Inform::Object.include(Inform::Privileges)
+      return unless @options[:admin]
+      give inform_library.player, :admin
+    end
+
+    def read_eval_print_loop
+      loop do
+        prompt
+        inform_library.send(inform_library.inform(read))
+      end
+    rescue Interrupt => e
+      $stdout.puts "\n#{e.class.name}"
+    end
+
+    def play_game
+      log.debug "#{self}#play_game"
+      invoke_main_method
+      # ensure_location
+      apply_preferences
+      manage_privileges
+      read_eval_print_loop
+    end
+
+    def quit
+      $stdout.print "[Hit enter to exit.]"
+      $stdin.getc
+      # Curses.getch
+      # Curses.close_screen
+      exit
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{object_id}>"
+    end
+
+    def inspect
+      to_s
+    end
+  end
+  # module RuntimeInstanceMethods
+
+  # The Inform::Privileges module to implement privilege
+  module Privileges
+    def admin?
+      self.has?(:admin)
+    end
+
+    def builder?
+      admin? || self.has?(:builder)
+    end
+  end
+
+  # The Runtime class loads a game and plays it in a REPL session.
+  class Runtime
+    include Inform::RuntimeConstants
+    include Inform::RuntimeInstanceMethods
+    include Inform::Game::Loader
+    include Inform::Library::Loader
+    include Inform::IO
+    include Inform::Publisher
+
+    class << self
+      include Inform::RuntimeClassMethods
+      include Inform::Library::ClassMethods
+    end
+
+    @default_config = nil
+    @instance = nil
+    @instance_mutex = Mutex.new
+
+    private_class_method :new
+
+    def initialize(options = Inform::Runtime.default_config)
+      @options = options
+      Inform::Game.init(@options)
+      Inform::Context.set(invocation_context)
+      Inform.initialize_persistence_layer
+    end
+  end
+  # class Runtime
+
+  # The App module
+  module App
+    include Inform::Options
+
+    def main(args = parse_arguments)
+      Logging.log_level = args[:log_level]
+      runtime = Inform::Runtime.init(args)
+      runtime.load_game
+      runtime.play_game
+    end
+  end
+end
+# module Inform
+
+if defined?(ZCODE_ONLY)
+  # Simulate compiling with Z-code only compiler
+  WORDSIZE = (2**((0.size * 8) - 2) - 1)
+end
+# defined?(ZCODE_ONLY)

data/lib/runtime/session.rb

@@ -0,0 +1,202 @@
+# 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 SessionManagementMethods module
+module SessionManagementMethods
+  Registry = Class.new(Hash)
+  SessionsByChannel = Registry.new
+
+  def add_promiscuous_states(*states)
+    Promiscuous.merge states.flatten
+  end
+
+  def sessions_by_channel
+    SessionsByChannel
+  end
+
+  def register(channel, session)
+    sessions_by_channel[channel] = session
+  end
+
+  def unregister(channel)
+    sessions_by_channel.delete(channel)
+  end
+
+  def [](channel)
+    sessions_by_channel[channel]
+  end
+
+  def []=(channel, session)
+    sessions_by_channel[channel] = session
+  end
+
+  def include?(channel)
+    sessions_by_channel.include?(channel)
+  end
+
+  def get(channel)
+    sessions_by_channel[channel] ||= Session.new(channel)
+  end
+end
+# module SessionManagementMethods
+
+# The SessionStateManagementMethods module
+module SessionStateManagementMethods
+  def [](key)
+    @session_data[key.to_sym]
+  end
+
+  def []=(key, value)
+    @session_data[key.to_sym] = value
+  end
+
+  def include?(key)
+    keys.include?(key)
+  end
+
+  def keys
+    @session_data.keys
+  end
+
+  def values
+    @session_data.values
+  end
+
+  def delete(key)
+    @session_data.delete(key)
+  end
+end
+
+module Inform
+module IO
+# The Session class
+# TODO: Refactor method implementations into modules
+class Session
+  # These states accept any input, including no input
+  Promiscuous = Set.new
+  include SessionStateManagementMethods
+
+  class << self
+    include SessionManagementMethods
+  end
+  attr_accessor :channel, :state, :status
+  attr_reader :last_good_state, :last_activity, :previous, :inbound, :outbound, :settings
+
+  def initialize(channel = nil)
+    init_channel_session(channel) unless channel.nil?
+    @status = nil
+    @last_good_state = @state = default if respond_to? :default
+    @session_data = {}
+    @settings = {}
+  end
+
+  def init_channel_session(channel)
+    Session[channel] = self
+    @channel = channel
+    @inbound = Inbound.new(self)
+    @outbound = Outbound.new(self)
+    @last_activity = Time.now
+  end
+
+  def receive(message)
+    return if message.nil? # It is okay if the message parameter is an empty string
+    return disconnected if @channel.nil?
+    return disconnected unless @channel.isActive() && @channel.isOpen()
+    process(sanitize(message))
+  end
+
+  def update(machine = self)
+    safely_progress(machine)
+    after_update if self.respond_to?(:after_update)
+    @last_good_state = @state unless @state == :confused
+  end
+
+  def after_update
+    # Override for application implementations
+  end
+
+  def sanitize(message)
+    message.to_s.strip.scan(/[[:print:]]/).join
+  end
+
+  def session
+    self
+  end
+
+  ExitCommandPattern = /^(exit|quit|q)$/i.freeze
+
+  def exit_command?(message)
+    !Promiscuous.include?(@state) && ExitCommandPattern.match?(message)
+  end
+
+  def process(message)
+    return disconnect if exit_command?(message)
+    @buffer = message
+    @last_activity = Time.now
+    @status = :active
+    if valid_state?
+      update
+    else
+      @inbound.publish @buffer
+    end
+
+    respond
+  end
+
+  def respond
+    flush_io
+  end
+
+  def safely_progress(machine = self)
+    @state = machine.send(@state)
+    raise 'Bad state machine implementation: nil state' if @state.nil?
+  rescue StandardError => e
+    log.error "Error updating state: #{e.message}", e
+    log.warn "Reverting to last known good state #{@last_good_state}"
+    @state = @last_good_state
+  end
+
+  def valid_state?(machine = self)
+    case @state
+    when String, Symbol
+      machine.respond_to? @state
+    else
+      false
+    end
+  end
+
+  def confused
+    println "The session is in an unknown state: #{@state}"
+    println "The last known good session state was: #{@last_good_state}"
+    println "Reverting the session to its last known good state, for better or worse."
+    prompt
+    @last_good_state
+  end
+end
+# class Session
+
+# The Connection class
+class Connection; end
+end
+# module IO
+end
+# module Inform