inform-runtime 1.0.4 → 1.2.0

data/lib/runtime/options.rb

@@ -1,104 +0,0 @@
-# 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 'logger'
-require 'optparse'
-
-require_relative 'version'
-
-# The Inform module
-module Inform
-  # The Options module
-  module Options
-    # The ArgumentsParser
-    class ArgumentsParser
-      attr_reader :parser, :options
-
-      def initialize(args, option_parser = OptionParser.new, **params)
-        @parser = option_parser
-        @options = ::Inform::Runtime.default_config.dup
-        flags.each { |method_name| self.method(method_name).call }
-        @parser.parse!(args, **params)
-      end
-
-      def flags
-        @flags ||= %i[banner admin log_level help version]
-      end
-
-      def banner
-        @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [game_path] [options]"
-        @parser.separator ''
-        @parser.separator 'Arguments:'
-        @parser.separator '    game_path                        Path to game file or directory'
-        @parser.separator ''
-        @parser.separator 'Options:'
-      end
-
-      def admin
-        @parser.on_tail('--admin', 'Set player character as admin; default: false') do
-          @options[:admin] = true
-        end
-      end
-
-      def log_level
-        @parser.on_tail('-v', '--verbose', 'Increase verbosity') do
-          @options[:log_level] ||= Logger::INFO
-          @options[:log_level] -= 1
-        end
-      end
-
-      def help
-        @parser.on_tail('-?', '--help', 'Show this message') do
-          puts @parser
-          exit
-        end
-      end
-
-      def version
-        @parser.on_tail('--version', 'Show version') do
-          puts "#{$PROGRAM_NAME} version #{Inform::VERSION}"
-          exit
-        end
-      end
-    end
-    # class ArgumentsParser
-
-    def demand(options, arg, positional = false)
-      return options[arg] unless options[arg].nil?
-      required_arg = positional ? "<#{arg}>" : "--#{arg.to_s.gsub(/_/, '-')}"
-      raise UserError, "Required argument: #{required_arg}"
-    end
-
-    def parse_arguments(args = ARGV, _file_path = ARGF)
-      arguments_parser = ArgumentsParser.new(args)
-      demand(arguments_parser.options, :game_path)
-      arguments_parser.options
-    rescue OptionParser::InvalidArgument, OptionParser::InvalidOption,
-           OptionParser::MissingArgument, OptionParser::NeedlessArgument => e
-      puts e.message
-      puts arguments_parser.parser
-      exit
-    rescue OptionParser::AmbiguousOption => e
-      abort e.message
-    end
-  end
-  # module Options
-end
-# module Inform

data/lib/runtime/persistence.rb

@@ -1,292 +0,0 @@
-# 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 'etc'
-require 'logger'
-require 'uri'
-require 'yaml'
-
-require 'sequel'
-
-require_relative 'database'
-
-Sequel.extension :migration
-Sequel.extension :connection_validator
-
-# Re-open the Inform module to define a helper method
-module Inform
-  def self.initialize_persistence_layer
-    log.debug "Inform.initialize_persistence_layer"
-    Inform::Persistence.init
-  end
-end
-
-# Simplistic in-memory cache
-class EphemeralCache < Hash
-  def get(key)
-    self[key]
-  end
-  def set(key, value, _ttl)
-    self[key] = value
-  end
-end
-
-# The Persistence class
-class Persistence
-  unless defined?(Persistence::GlobalCache)
-    GlobalCache = defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : EphemeralCache.new
-  end
-  Plugins = {
-    after_initialize: [],
-    caching: [Persistence::GlobalCache],
-    json_serializer: [],
-    xml_serializer: []
-  #   tactical_eager_loading: [],
-  #   eager_each: []
-  }.freeze
-end
-
-# The SequelLoggers module
-module SequelLoggers
-  DatabaseLogging = Struct.new(:memo).new({})
-
-  def add_logger(database, logger)
-    database.loggers << logger unless database.loggers.include?(logger)
-  end
-
-  def delete_logger(database, logger)
-    database.loggers.delete(logger) if database.loggers.include?(logger)
-  end
-
-  def set_log_level(database, level)
-    DatabaseLogging.memo[:preserved_log_levels][database] = database.sql_log_level
-    database.sql_log_level = level unless level.nil?
-  end
-
-  def enable_query_logging
-    DatabaseLogging.memo[:logger] ||= Logger.new($stdout)
-    DatabaseLogging.memo[:preserved_log_levels] ||= {}
-    logger = DatabaseLogging.memo[:logger]
-    Sequel::DATABASES.each do |database|
-      add_logger(database, logger)
-      set_log_level(database, :debug)
-      logger.debug "Enabled query logging for #{database}"
-    end
-  end
-
-  def disable_query_logging
-    logger = DatabaseLogging.memo[:logger]
-    Sequel::DATABASES.each do |database|
-      logger.debug "Disabling query logging for #{database}"
-      delete_logger(database, logger)
-      set_log_level(database, DatabaseLogging.memo[:preserved_log_levels][database])
-    end
-  end
-end
-# module SequelLoggers
-
-# The SequelPlugins module
-module SequelPlugins
-  def enable_plugins
-    Persistence::Plugins.each { |plugin, parameters| enable_plugin(plugin, parameters) }
-  end
-
-  def enable_plugin(plugin, parameters = [])
-    return Sequel::Model.plugin(plugin) if parameters.empty?
-    Sequel::Model.plugin(plugin, *parameters)
-  rescue LoadError => e
-    log.error e.message
-  end
-end
-# module SequelPlugins
-
-# The Inform module
-module Inform
-  # The Persistence class
-  class Persistence
-    include DatabaseConnectionHelpers
-    include SequelLoggers
-    include SequelPlugins
-
-    attr_reader :config, :environment
-
-    def self.init(env = nil)
-      Inform::Persistence.instance(env)
-    end
-
-    @instance_mutex = Mutex.new
-
-    def self.instance(*args)
-      return @instance unless @instance.nil?
-      @instance_mutex.synchronize do
-        @instance ||= new(*args)
-      end
-      @instance
-    end
-
-    private_class_method :new
-
-    def initialize(env = nil)
-      @environment = env || Inform::Game.environment
-      log.debug "Initializing persistence layer for environment: #{@environment}"
-      caller[0..4].each { |t| log.debug t }
-      @config = database_config.fetch(@environment.to_s, {})
-      establish_database_connection
-      enable_plugins
-      enable_query_logging if ENV['ENABLE_SQL_LOGGING']
-    end
-
-    def establish_database_connection
-      connect
-    rescue Sequel::DatabaseConnectionError
-      log.warn "Database requires initialization"
-      init_database
-      retry if ConnectionAttempts.memo < 2
-    end
-
-    def database_config
-      @database_config ||= YAML.load_file(database_config_file_path)
-    end
-
-    def database_config_file_path
-      @database_config_file_path ||= File.expand_path(
-        File.join(Inform::Runtime.project_dir_path, 'config', 'database.yml')
-      )
-    end
-
-    def init_database
-      @config = database_config.fetch('default')
-      connect
-      @database = Inform::Database.instance(Inform::Game.config[:database_name])
-      @database.bootstrap.up
-      @config = database_config.fetch(environment.to_s)
-      connect
-    end
-  end
-  # class Persistence
-end
-# module Inform
-
-# The Inform module
-module Inform
-  # The ImplicitMigration module
-  module ImplicitMigration
-    NoDatabasePattern = %r{No database associated with Sequel::Model}.freeze
-    MigrationSetupTemplate = '%<model>sSetup'.freeze
-    ModuleNamespaceDelimiterPattern = /::/.freeze
-
-    def before_inherited(subclass)
-      return if self != Sequel::Model
-      descendants << subclass
-      log.debug "#{subclass} << #{self} [#{descendants}]"
-      maybe_migrate(subclass)
-    end
-
-    def after_inherited(_subclass)
-      examine_schema
-    end
-
-    # rubocop: disable Metrics/AbcSize
-    # rubocop: disable Metrics/MethodLength
-    def examine_schema
-      descendants.each do |model_class|
-        table_name = model_class.table_name
-        indexes = self.db.indexes(table_name)
-        columns = model_class.columns
-        associations = model_class.associations
-
-        log.debug "Table: #{table_name}"
-        log.debug "Columns: #{columns.join(', ')}"
-        log.debug "Indexes: #{indexes}"
-
-        associations.each do |assoc_name, assoc_data|
-          log.debug "Association: #{assoc_name} (#{assoc_data[:type]}) to #{assoc_data[:class_name]}"
-        end
-
-        log.debug "==========="
-      end
-    end
-    # rubocop: enable Metrics/AbcSize
-    # rubocop: enable Metrics/MethodLength
-
-    def maybe_migrate(subclass)
-      migration_class = migration(subclass)
-      log.debug "Found migration class: #{migration_class}"
-      migration_class&.up
-    rescue Sequel::Error => e
-      if NoDatabasePattern.match?(e.message)
-        Inform::Persistence.instance.connect
-        retry
-      end
-    end
-
-    def migration(model)
-      names = format(MigrationSetupTemplate, model: model).split(ModuleNamespaceDelimiterPattern)
-      names.inject(Object) do |mod, class_name|
-        mod.const_get(class_name)
-      rescue StandardError => e
-        log.warn "Error getting reference to migration model class: #{e.message}"
-        next
-      end
-    end
-  end
-  # module ImplicitMigration
-end
-# module Inform
-
-# The Inform module
-module Inform
-  # The InheritanceListener module
-  module InheritanceListener
-    # The ClassMethods module
-    module ClassMethods
-      include Inform::ImplicitMigration
-
-      def inherited(subclass)
-        before_inherited(subclass)
-        super
-        after_inherited(subclass)
-      end
-
-      # Returns the list of Model descendants.
-      def descendants
-        @descendants ||= []
-      end
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-  end
-  # module InheritanceListener
-end
-# module Inform
-
-# The Sequel module
-module Sequel
-  # The Sequel::Model class
-  class Model
-    include Inform::InheritanceListener
-
-    def self.implicit_table_name
-      underscore(demodulize(name)).to_sym
-    end
-  end
-end

data/lib/runtime/runtime.rb

@@ -1,321 +0,0 @@
-# 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)