inform-runtime 1.0.4

data/lib/runtime/experimental/handler_dsl.rb

@@ -0,0 +1,175 @@
+# 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/>.
+
+# The Inform module
+module Inform
+  # TODO: Testme
+  # class Object
+  #   def after_initialize
+  #     super
+  #     return if new?
+  #     Inform::Behavior.attach(self)
+  #     apply_instance_behavior!
+  #   end
+
+  #   def after_refresh
+  #     super
+  #     apply_instance_behavior!
+  #   end
+  # end
+
+  # The Inform::Behavior module
+  module Behavior
+    Registry = Class.new(Hash)
+    REGISTRY = Registry.new
+
+    def self.key_for(obj)
+      return obj.identity if obj.respond_to?(:identity) &&
+        !(obj.identity.nil? || obj.identity.empty?)
+      "<##{obj.class}:#{obj.name}>"
+    end
+
+    def self.register(obj, mod)
+      Inform::Behavior::REGISTRY[key_for(obj)] = mod
+    end
+
+    def self.attach(obj)
+      if (mod = Inform::Behavior::REGISTRY[key_for(obj)])
+        obj.extend(mod)
+      end
+      obj
+    end
+  end
+
+  # The BehaviorError class
+  class BehaviorError < TypeError
+    MESSAGE = 'Behavior registry for %<key>s is not a Module (got %<clazz>s)'.freeze
+    def initialize(key, behavior)
+      super(format(MESSAGE, key: key, clazz: behavior.class))
+    end
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def with(context = nil, key = Inform::Behavior.key_for(self), &block)
+    log.debug "with.self=#{self.inspect} (#{self.identity})"
+    behavior = Inform::Behavior::REGISTRY[key] ||= ::Module.new
+    ensure_behavior_module!(key, behavior)
+
+    unless block.nil?
+      proxy = context_proxy(context || self, block.binding)
+      b = builder(self, behavior, proxy)
+      klass = b.class
+      before = klass.instance_methods(false)
+
+      b.instance_exec(proxy, &block)
+
+      added = klass.instance_methods(false) - before
+      added.each do |m|
+        behavior.define_method(m, klass.instance_method(m))
+      end
+    end
+
+    extend_and_persist(behavior)
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+
+  # rubocop: disable Metrics/MethodLength
+  def context_proxy(target, context, proxy = Object.new)
+    return target if context.nil?
+
+    proxy.define_singleton_method(:method_missing) do |method_name, *args, &block|
+      if context.local_variable_defined?(method_name)
+        context.local_variable_get(method_name)
+      elsif target.respond_to?(method_name)
+        target.public_send(method_name, *args, &block)
+      else
+        super(method_name, *args, &block)
+      end
+    end
+
+    proxy.define_singleton_method(:respond_to_missing?) do |method_name, include_private = false|
+      context.local_variable_defined?(method_name) || target.respond_to?(method_name, include_private)
+    end
+
+    proxy
+  end
+  # rubocop: enable Metrics/MethodLength
+
+  def extend_and_persist(behavior)
+    self.extend(behavior)
+    self.save_changes if self.respond_to?(:save_changes)
+    self
+  end
+
+  def ensure_behavior_module!(key, behavior)
+    raise BehaviorError.new(key, behavior) unless behavior.is_a?(::Module)
+  end
+
+  # The BuilderInstanceMethods module
+  module BuilderInstanceMethods
+    # Unknown method with a block => define it on behavior.
+    # def method_missing(method_name, *args, &block)
+    #   return @target.public_send(method_name, *args) if block.nil?
+    #   local_context = @context
+    #   @behavior.send(:define_method, method_name) do |*call_args, &_block|
+    #     instance_exec(local_context, *call_args, &block)
+    #   end
+    #   method_name
+    # rescue NoMethodError
+    #   super
+    # end
+
+    def method_missing(method_name, *args, &block)
+      # 1) Try the real receiver first (even when a block is present)
+      log.debug "@target: #{@target.inspect}"
+      return @target.public_send(method_name, *args) if block.nil?
+      return @target.public_send(method_name, *args, &block) if @target.respond_to?(method_name)
+
+      # 2) Unknown method + block => define DSL method on behavior
+      return super if block.nil?
+
+      local_context = @context
+      @behavior.send(:define_method, method_name) do |*call_args, &_block|
+        instance_exec(local_context, *call_args, &block)
+      end
+      method_name
+    end
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    def define_singleton_method(*args, &blk)
+      @target.define_singleton_method(*args, &blk)
+    end
+  end
+
+  def builder(target, behavior, context)
+    Class.new do
+      def initialize(target, behavior, context)
+        @target, @behavior, @context = target, behavior, context
+        self.extend(BuilderInstanceMethods)
+      end
+    end.new(target, behavior, context)
+  end
+end
+# module Inform

data/lib/runtime/game.rb

@@ -0,0 +1,74 @@
+# 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 'yaml'
+
+require_relative 'game_loader'
+
+# The Inform module
+module Inform
+  # The Game module
+  module Game
+    @config = {}
+
+    def init(options)
+      Inform::Game.config[:game_path] = game_dir_path(options[:game_path])
+      Inform::Game.config[:game_config_file_path] =
+        game_config_file_path(Inform::Game.config[:game_path])
+      Inform::Game.config.update(
+        YAML.load_file(Inform::Game.config[:game_config_file_path], symbolize_names: true)
+      )
+    end
+    module_function :init
+
+    def config
+      @config
+    end
+    module_function :config
+
+    def environment
+      (ENV['GAME_ENVIRONMENT'] || config[:environment] || Inform::Runtime.default_environment).to_sym
+    end
+    module_function :environment
+
+    def environment=(env)
+      config[:environment] = env.to_sym
+    end
+    module_function :environment=
+
+    private
+
+    def game_config_file_path(path)
+      File.join(path, 'config.yml')
+    end
+    module_function :game_config_file_path
+
+    def game_dir_path(path)
+      return path if File.directory?(path)
+      Inform::Game.config[:game_file_path] = path
+      game_dir_path = File.expand_path(File.dirname(path))
+      return game_dir_path if File.exist?(game_config_file_path(game_dir_path))
+      Inform::Runtime.default_game_dir_path
+    end
+    module_function :game_dir_path
+  end
+  # module Game
+end
+# module Inform

data/lib/runtime/game_loader.rb

@@ -0,0 +1,132 @@
+# 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/>.
+
+# The Inform module
+module Inform
+  # The Game module
+  module Game
+    class GameLoadError < StandardError; end
+
+    # The Game::Loader module loads a game from a given directory.
+    module Loader
+      def load_game(game_dir_path = Inform::Game.config[:game_path])
+        self.load_path = game_dir_path
+        require_relative 'world_tree'
+        load_game_subcomponents
+        load_game_files
+        load_grammars
+        reset_constants
+        load_library
+      rescue StandardError => e
+        handle_load_failure(e)
+      end
+
+      def first_orphan_object_with_description_that_has_light
+        Inform::Object.all.find { |o| !o.description.nil? && o.has?(:light) }&.name
+      end
+
+      def load_path=(path)
+        @game_dir_path = path
+        $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+      end
+
+      def load_game_subcomponents
+        game_components.each { |component| load_game_sub(component) }
+      end
+
+      def reset_constants
+        reset_constant(:HDR_GAMESERIAL, defined?(Serial) ? Serial : File.mtime(@game_dir_path).strftime('%y%m%d'))
+        reset_constant(:HDR_GAMERELEASE, defined?(Release) ? Release : 0)
+      end
+
+      def load_game_sub(component, start = Time.now)
+        game_component_path = File.join(@game_dir_path, component.to_s)
+        Dir.glob(File.join(game_component_path, '*')).sort.each do |file|
+          next unless File.file?(file)
+          log.debug "Loading file: #{file}"
+          require file
+        end
+      ensure
+        elapsed = (Time.now - start) * 1000
+        log.debug format("Loaded #{component} in %0.2f milliseconds", elapsed)
+      end
+
+      def load_game_files(game_path = @game_dir_path)
+        log.info "Loading game: #{game_path}"
+        Dir.glob(File.join(game_path, '*.rb')).sort.each do |file|
+          next unless File.file?(file)
+          log.debug "Loading file: #{file}"
+          require file
+        end
+      end
+
+      def handle_load_failure(e)
+        case e.message
+        when /PG::UndefinedTable/
+          log.error "Fatal: Database initialization is required"
+          abort
+        else
+          log.error "Error loading game: #{e.class.name}: #{e.message}"
+          e.backtrace.each { |t| log.error t }
+        end
+      end
+
+      # Move to the front of the list any element matching the given condition
+      def prioritize_if(list, &condition)
+        element = list.find(&condition)
+        return list if element.nil?
+        list.unshift(list.delete(element))
+      end
+
+      EnsureFirst = [/emotes.inf/, /grammar.inf/].freeze
+
+      def grammar_files
+        files = Dir.glob(File.join(grammar_module_path, '*'))
+        EnsureFirst.each do |pattern|
+          prioritize_if(files) { |file_path| file_path.match?(pattern) }
+        end
+        files
+      end
+
+      GrammarParsedInfoMessage = 'Parsed grammar %<file>s in %0.2<elapsed>f milliseconds'.freeze
+
+      def load_grammars
+        grammar_files.each do |file_path|
+          start = Time.now
+          Inform.load_grammar_by_path(file_path)
+          elapsed = (Time.now - start) * 1000
+          log.debug format(GrammarParsedInfoMessage, file: File.basename(file_path), elapsed: elapsed)
+        end
+      end
+
+      def load_game_states
+        states = Inform::Game.config.fetch(:additional_promiscuous_states, []).map(&:to_sym)
+        Session.add_promiscuous_states(states)
+      end
+
+      def reload_game
+        load_game
+      end
+    end
+    # module Loader
+  end
+  # module Game
+end
+# module Inform