story-teller 1.1.3

data/lib/story_teller/game/loader.rb

@@ -0,0 +1,276 @@
+# lib/story_teller/game/loader.rb
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+#
+# This file is part of the StoryTeller.
+#
+# The StoryTeller 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 StoryTeller 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 StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'yaml'
+
+# The StoryTeller module
+module StoryTeller
+  # The Game class
+  class Game
+    attr_reader :config, :config_file_path, :file_path, :path
+
+    def initialize(options)
+      @config = {}
+      @path, @file_path = game_paths(options)
+      @config_file_path = File.join(@path, options[:game_config_file_name])
+      @config = YAML.load_file(@config_file_path, symbolize_names: true)
+      @config[:game_file_path] = @file_path unless @file_path.nil?
+    end
+
+    def name
+      @config[:game_name]
+    end
+
+    def environment
+      (
+        ENV['GAME_ENVIRONMENT'] ||
+        @config[:environment] ||
+        StoryTeller::Engine.default_environment
+      ).to_sym
+    end
+
+    def environment=(env)
+      @config[:environment] = env.to_sym
+    end
+
+    private
+
+    def game_paths(options)
+      path = File.expand_path(options[:game_path])
+      path = StoryTeller::Config.default_game_dir_path unless game_config_exists?(path, options)
+      return [path, nil] if File.directory?(path)
+
+      [File.dirname(path), path]
+    end
+
+    def game_config_exists?(path, options)
+      config_dir = File.directory?(path) ? path : File.dirname(path)
+      File.exist?(File.join(config_dir, options[:game_config_file_name]))
+    end
+
+    def game_dir_path(path)
+      return path if File.directory?(path)
+      @config[:game_file_path] = path
+      @game_dir_path = File.expand_path(File.dirname(path))
+      return @game_dir_path if File.exist?(@config_file_path)
+      StoryTeller::Config.default_game_dir_path
+    end
+
+    class GameLoadError < StandardError; end
+
+    # The Game::Loader module loads a game from a given directory.
+    module Loader
+      PreGameComponents = %i[modules].freeze
+
+      def load_game(game_dir_path = game_path)
+        self.load_path = game_dir_path
+        load_game_subcomponents(pre_game_components)
+        load_game_files(top_level_game_path(game_dir_path))
+        load_library
+        load_game_subcomponents(post_game_components)
+        load_grammars
+        reset_constants
+      rescue StandardError => e
+        handle_load_failure(e)
+        raise
+      end
+
+      def top_level_game_path(game_dir_path)
+        return game_dir_path unless same_path?(game_dir_path, game.path)
+
+        game.file_path || game_dir_path
+      end
+
+      def same_path?(first, second)
+        File.expand_path(first) == File.expand_path(second)
+      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(components = game_components)
+        components.each { |component| load_game_sub(component) }
+      end
+
+      def pre_game_components
+        game_components & PreGameComponents
+      end
+
+      def post_game_components
+        game_components - pre_game_components
+      end
+
+      def reset_constants
+        reset_constant(:HDR_GAMESERIAL, game_serial)
+        reset_constant(:HDR_GAMERELEASE, release)
+      end
+
+      def game_serial
+        defined?(::Serial) ? ::Serial : File.mtime(@game_dir_path).strftime('%y%m%d')
+      end
+
+      def release
+        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, '*')).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 story game #{game.name} from #{game_path}"
+      #   Dir.glob(File.join(game_path, '*.rb')).each do |file|
+      #     next unless File.file?(file)
+      #     log.trace "Loading file: #{file}"
+      #     require file
+      #   end
+      #   log.debug "Loaded story game #{game.name}"
+      # end
+
+      def load_game_files(game_path = @game_dir_path)
+        log.info "Loading story game #{game.name} from #{game_path}"
+
+        if preserve_persisted_world?
+          load_game_files_without_committing(game_path)
+        else
+          load_game_files_with_committing(game_path)
+        end
+
+        log.debug "Loaded story game #{game.name}"
+      end
+
+      def preserve_persisted_world?
+        options[:persist] && persistence.world_tree?
+      end
+
+      def load_game_files_with_committing(game_path)
+        game_files(game_path).each do |file|
+          log.trace "Loading file: #{file}"
+          require file
+        end
+      end
+
+      def game_files(game_path)
+        return [game_path] if File.file?(game_path)
+
+        Dir.glob(File.join(game_path, '*.rb')).select { |file| File.file?(file) }
+      end
+
+      def load_game_files_without_committing(game_path)
+        preserved_ids = persistence.world_object_ids
+
+        persistence.without_committing! do
+          load_game_files_with_committing(game_path)
+        end
+
+        refresh_preserved_world_objects(preserved_ids)
+      end
+
+      def refresh_preserved_world_objects(preserved_ids)
+        ObjectSpace.each_object(Inform::Object) do |object|
+          refresh_preserved_world_object(object, preserved_ids)
+        end
+      end
+
+      def refresh_preserved_world_object(object, preserved_ids)
+        return if object.id.nil?
+
+        unless preserved_ids.include?(object.id)
+          raise GameLoadError, "Source object is missing from preserved world: #{object.object_name}"
+        end
+
+        object.associations.clear if object.respond_to?(:associations)
+        object.refresh
+      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
+          StoryTeller::Library::Loader.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_library
+        StoryTeller::Library::Loader.load_library
+      end
+
+      def load_game_states
+        states = game.config.fetch(:additional_promiscuous_states, []).map(&:to_sym)
+        Session.add_promiscuous_states(states)
+      end
+
+      def reload_game
+        load_game
+      end
+    end
+    # module Loader
+
+    StoryTeller::Runtime.include(StoryTeller::Game::Loader)
+  end
+  # class Game
+end
+# module StoryTeller

data/lib/story_teller/game.rb

@@ -0,0 +1,22 @@
+# lib/story_teller/game.rb
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+#
+# This file is part of the StoryTeller.
+#
+# The StoryTeller 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 StoryTeller 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 StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'game/loader'

data/lib/story_teller/inform/models.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2026 but freely usable (see license)
+#
+# This file is part of StoryTeller.
+#
+# The StoryTeller 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 StoryTeller 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 StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative 'relational/object'
+require_relative 'relational/link'
+require_relative 'relational/module'
+require_relative 'relational/tag'
+
+# module Inform
+module Inform
+  # class Object
+  class Object
+    include StoryTeller::Builtins
+    include StoryTeller::IO if defined?(StoryTeller::IO)
+    include StoryTeller::Publisher if defined?(StoryTeller::Publisher)
+    include StoryTeller::Daemons if defined?(StoryTeller::Daemons)
+    include Inform::Context if defined?(Inform::Context)
+    include Inform::Events if defined?(Inform::Events)
+    include Inform::Prototypical if defined?(Inform::Prototypical)
+    prepend Inform::Linkable if defined?(Inform::Linkable)
+    include Inform::Taggable if defined?(Inform::Taggable)
+    include Inform::Modular if defined?(Inform::Modular)
+    include Inform::Genealogical if defined?(Inform::Genealogical)
+  end
+end

data/lib/story_teller/inform/relational/link.rb

@@ -0,0 +1,239 @@
+# lib/story_teller/inform/relational/link.rb
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2025 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/>.
+
+# Link
+
+if defined?(Sequel::Migration)
+# The LinkSetup class
+class LinkSetup < Sequel::Migration
+  # rubocop: disable Metrics/MethodLength
+  def up
+    # return if table_exists? :link
+    log.debug "#up"
+    create_table? :link do
+      primary_key :id
+      foreign_key :from_id, :object, on_delete: :cascade
+      foreign_key :to_id, :object, on_delete: :cascade
+      index :name
+      index :created_at
+
+      String :name
+      DateTime :created_at
+      DateTime :modified_at
+    end
+  end
+  # rubocop: enable Metrics/MethodLength
+
+  def down
+    drop_table :link if table_exists? :link
+  end
+end
+# class LinkSetup
+end
+# defined?(Sequel::Migration)
+
+# module Inform
+module Inform
+  # class Link
+  class Link < Sequel::Model
+    set_primary_key :id
+    def_column_accessor :created_at, :modified_at
+    def_column_accessor :name
+    many_to_one :from, class: Inform::Object, key: :from_id
+    many_to_one :to,   class: Inform::Object, key: :to_id
+
+    LinkTemplate = '%<link_name>s -> %<to_name>s [%<to_identity>s]'.freeze
+    LinkMethods = %w[from_id to_id].freeze
+    MethodWriterTemplate = '%<method_name>s='.freeze
+
+    def initialize(values = {}, &block)
+      super(self.class.relational_values(values), &block)
+    end
+
+    def self.relational_values(values)
+      return values unless values.is_a?(Hash)
+
+      values = values.dup
+      from = values.delete(:from)
+      to = values.delete(:to)
+      values[:from_id] ||= persisted_object_id(from)
+      values[:to_id] ||= persisted_object_id(to)
+      values
+    end
+
+    # rubocop: disable Metrics/CyclomaticComplexity
+    def self.persisted_object_id(object)
+      return nil if object.nil?
+      return object.id if object.respond_to?(:id) && object.id
+      object.save_changes if object.respond_to?(:save_changes)
+      return object.id if object.respond_to?(:id) && object.id
+      return object.pk if object.respond_to?(:pk)
+
+      nil
+    end
+    # rubocop: enable Metrics/CyclomaticComplexity
+
+    def before_create
+      self.created_at ||= Time.now
+      super
+    end
+
+    def after_save
+      super
+      self.modified_at = Time.now.utc
+    end
+
+    def to_s
+      format(LinkTemplate, link_name: name, to_name: to&.name, to_identity: to&.identity)
+    end
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def init_with(coder)
+      LinkMethods.each do |method_name|
+        method_symbol = format(MethodWriterTemplate, method_name: method_name).to_sym
+        self.send(method_symbol, coder[method_name]) if self.respond_to? method_symbol
+      end
+      self
+    end
+  end
+end
+# module Inform
+
+# module Inform
+module Inform
+  module_function
+
+  def link_klass
+    Inform::Link
+  end
+end
+
+# module Inform
+module Inform
+  # module Linkable
+  module Linkable
+    def links
+      return Array::Empty unless self.respond_to?(:id)
+      return Array::Empty if self.id.nil?
+
+      Inform.link_klass.filter(from_id: self.id).all
+    rescue StandardError => _e
+      Array::Empty
+    end
+
+    def find_link(link_name)
+      return nil unless self.respond_to?(:id)
+      return nil if self.id.nil?
+
+      Inform.link_klass.first(name: link_name.to_s, from_id: self.id)
+    end
+
+    # rubocop: disable Metrics/MethodLength
+    def link(link_name, obj = nil)
+      save_link_endpoint(self)
+      save_link_endpoint(obj)
+
+      link = find_link(link_name)
+      return link if obj.nil?
+
+      if link.nil?
+        clauses = { name: link_name.to_s, from_id: self.id, to_id: obj.id }
+        link = Inform.link_klass.find_or_create(**clauses)
+      else
+        link.to_id = obj.id
+        link.save
+      end
+      link
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def linked?(link_name)
+      return false unless self.respond_to?(:id)
+      return false if self.id.nil?
+
+      Inform.link_klass.filter(name: link_name.to_s, from_id: self.id).count > 0
+    end
+    alias _key? linked?
+
+    def unlink(link_name)
+      link = find_link(link_name)
+      return nil if link.nil?
+
+      object = linked_object(link.to_id)
+      link.destroy
+      object
+    rescue Sequel::NoExistingObject => e
+      log.warn 'Error: ' + e.message
+      log.warn 'No such link: ' + link_name.to_s
+      nil
+    end
+    alias _unset_object unlink
+
+    def linkto(link_name)
+      link = find_link(link_name)
+      link.nil? ? nil : linked_object(link.to_id)
+    end
+    alias _get_object linkto
+
+    def _set_object(link_name, obj = nil)
+      return nil if obj.nil?
+
+      link(link_name, obj)
+      obj
+    end
+
+    def linksfrom(link_name = nil)
+      return Array::Empty unless self.respond_to?(:id)
+      return Array::Empty if self.id.nil?
+
+      dataset = Inform.link_klass.filter(to_id: self.id)
+      dataset = dataset.filter(name: link_name.to_s) unless link_name.nil?
+      dataset.all.map { |link| linked_object(link.from_id) }.compact
+    end
+
+    private
+
+    def save_link_endpoint(object)
+      return if object.nil?
+      return if object.respond_to?(:id) && object.id
+
+      if object.respond_to?(:save_changes)
+        object.save_changes
+      elsif object.respond_to?(:save)
+        object.save
+      end
+    end
+
+    def linked_object(id)
+      return nil if id.nil?
+      return Inform::Object[id] if defined?(Inform::Object) && Inform::Object.respond_to?(:[])
+      return Inform::Ephemeral::Object[id] if defined?(Inform::Ephemeral::Object) &&
+        Inform::Ephemeral::Object.respond_to?(:[])
+
+      nil
+    end
+  end
+  # module Linkable
+end
+# module Inform