story-teller 1.1.3

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

@@ -0,0 +1,546 @@
+# lib/story_teller/inform/relational/object.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/>.
+
+require 'sequel'
+
+# Object
+
+if defined? Sequel::Migration
+  # The ObjectSetup class
+  class ObjectSetup < Sequel::Migration
+    # rubocop: disable Metrics/MethodLength
+    def up
+      create_table? :object do
+        primary_key :id
+        foreign_key :parent_id, :object, on_delete: :set_null
+        index :name
+        index :created_at
+
+        String :name, text: true
+        String :short_name, text: true
+        String :description, text: true
+        String :object_type, null: false
+        String :properties, text: true, default: {}.to_yaml.strip
+        DateTime :created_at
+        DateTime :modified_at
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def down
+      drop_table(:object, cascade: true) if table_exists? :object
+    end
+  end
+end
+
+# if defined? ObjectSetup
+#   ObjectSetup.down if ObjectSetup.respond_to?(:down)
+# end
+if defined? ObjectSetup
+  ObjectSetup.up if ObjectSetup.respond_to?(:up)
+end
+
+def Object(name, klass = Inform::Object, &block)
+  obj = if klass.respond_to?(:fetch_or_create_by_name)
+    klass.fetch_or_create_by_name(name)
+  else
+    klass.new(name)
+  end
+  obj.with(&block) if block_given?
+  obj.save_changes if obj.respond_to?(:save_changes)
+  obj
+end
+
+# The Inform module
+module Inform
+  # The Inform::Object class
+  # rubocop: disable Metrics/ClassLength
+  class Object < Sequel::Model
+    logger
+    plugin :rcte_tree
+    plugin :serialization
+    plugin :single_table_inheritance, :object_type
+    serialize_attributes :yaml, :properties
+
+    one_to_many :links, join_table: :link, key: :from_id
+    one_to_many :tagged, key: :object_id
+    one_to_many :modularized, key: :object_id
+    many_to_many :modules,
+                 class: 'Inform::Module',
+                 join_table: :modularized,
+                 left_key: :object_id,
+                 right_key: :module_id
+    many_to_many :tags,
+                 class: 'Inform::Tag',
+                 join_table: :tagged,
+                 left_key: :object_id,
+                 right_key: :tag_id
+    one_to_many :children,
+                key: :parent_id,
+                class: self,
+                order: %i[name id],
+                eager: %i[modules tags links]
+
+    # rubocop: disable Metrics/MethodLength
+    def initialize(*args, &block)
+      if args.empty?
+        super(&nil)
+      elsif args.first.is_a?(String)
+        short_name = args.first
+        super({ name: short_name, short_name: short_name }, &nil)
+      else
+        super(*args, &nil)
+      end
+      save
+      @tags_semaphore = Mutex.new
+      @semaphore = Mutex.new
+      self.with(&block) unless block.nil?
+      log.debug "Initializing #{self}"
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def self.fetch_or_create_by_name(name)
+      key = name.to_s
+      object = first(name: key)
+      object ||= all.find { |candidate| candidate.name_values.include?(key) }
+      object || new(key)
+    end
+
+    def name_values
+      Array(self.values[:name]).flatten.map(&:to_s)
+    end
+
+    # def name(*args)
+    #   return args.first.object_name if args.first.respond_to?(:object_name)
+    #   return self.values[:name] if args.empty?
+
+    #   self.values[:name] = args.length > 1 ? args.join(' ') : args
+    #   self.save
+    #   self.values[:name]
+    # end
+    def name(*args)
+      return args.first.object_name if args.first.respond_to?(:object_name)
+      return self.values[:name] if args.empty?
+
+      names = args.flatten
+      self.values[:name] = names
+      self.save
+      self.values[:name] = names
+    end
+
+    def name=(value)
+      name(value)
+    end
+
+    # def name_words
+    #   self.values[:name].split(/[,\s]+/).join(', ')
+    # end
+    def name_words
+      name_values.join(', ')
+    end
+
+    # rubocop: disable Metrics/MethodLength
+    def short_name(*args)
+      unless args.empty?
+        self.short_name = args.first
+        return
+      end
+
+      textual_name = self.values[:short_name]
+      synonyms = self.values[:name]
+      if textual_name.nil? || (textual_name.respond_to?(:empty?) && textual_name.empty?)
+        self.values[:short_name] = synonyms
+        self.save
+        self.values[:short_name]
+      else
+        textual_name
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def object_name
+      self.values[:display_name] || self.values[:short_name] || self.values[:name]
+    end
+
+    # def description(*args)
+    #   return self.values[:description] if args.empty?
+
+    #   value = args.length > 1 ? args.join : args.first
+    #   self.values[:description] = value
+    #   self.save_changes if self.respond_to?(:save_changes)
+    #   value
+    # end
+
+    # alias description= description
+
+    def description(*args)
+      return self[:description] if args.empty?
+
+      value = args.length > 1 ? args.join : args.first
+      self[:description] = value
+      save_changes if respond_to?(:save_changes)
+      value
+    end
+
+    def description=(value)
+      self[:description] = value
+      save_changes if respond_to?(:save_changes)
+    end
+
+    def semaphore
+      @semaphore ||= Mutex.new
+    end
+
+    def tags_semaphore
+      @tags_semaphore ||= Mutex.new
+    end
+
+    alias tags_original tags
+
+    def tags
+      tags_semaphore.synchronize { tags_original }
+    end
+
+    def routines
+      ((self.methods - Object.instance_methods) - Inform::Object.instance_methods).sort.uniq
+    end
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def ==(other)
+      other.respond_to?(:values) ? self.values[:id] == other.values[:id] : super
+    end
+
+    def parse(s)
+      return if inflib.nil?
+
+      semaphore.synchronize do
+        inflib.parse s
+      end
+    end
+
+    def invoke(a, *args)
+      return if inflib.nil?
+
+      inflib.invoke(a, *args)
+    end
+
+    def _invoke(a, *args)
+      return if inflib.nil?
+
+      inflib._invoke(a, *args)
+    end
+
+    def __invoke(a, *args)
+      return if inflib.nil?
+
+      inflib.__invoke(a, *args)
+    end
+
+    def inflib
+      return InformLibrary[self] if self.has?(:animate) ||
+        defined?(Character) && self.is_a?(Character)
+
+      @inflib
+    end
+
+    # rubocop: disable Style/TrivialAccessors
+    def inflib=(inflib)
+      @inflib = inflib
+    end
+    # rubocop: enable Style/TrivialAccessors
+
+    def print_zmachine_result(s, should_prompt: true)
+      inflib&.print_zmachine_result(s, should_prompt:)
+    end
+
+    def print_evented_zmachine_result(s, isolate: false)
+      inflib&.print_evented_zmachine_result(s, isolate: isolate)
+    end
+
+    Visited = defined?(ConcurrentHashMap) ? ConcurrentHashMap.new : {}
+
+    def visited
+      Visited[self] ||= []
+    end
+
+    def after_create
+      super
+      index_words if respond_to?(:index_words)
+      init
+    end
+
+    def init
+      # A designer should implement this in a subclass if necessary
+    end
+
+    def safe_refresh
+      self.refresh
+    rescue Sequel::NoExistingObject => e
+      log.warn "Object refresh failure: #{e.message}; ignoring"
+    end
+
+    def safe_save
+      self.save
+    rescue Sequel::NoExistingObject => e
+      log.warn "Object save failure: #{e.message}; ignoring"
+    end
+
+    def safe_init
+      self.init if self.respond_to? :init
+    rescue Sequel::NoExistingObject => e
+      log.warn "Object initialization failure: #{e.message}; ignoring"
+    end
+
+    def classify_as(klass)
+      return if klass.nil?
+
+      klass = find_class klass unless klass.is_a? Class
+      self.object_type = klass.name
+      self.safe_save
+      self.safe_init
+      o = Inform::Object[self.id]
+      log.debug "o.object_type: #{o.object_type}"
+      return o
+    end
+
+    # def ephemeral_children
+    #   EphemeralObjectsChildren[identity] ||= []
+    # end
+
+    # # TODO: Implement a unit test for this
+    # def <<(o)
+    #   return if o.nil?
+    #   return if o == self
+
+    #   if o.ephemeral?
+    #     o.parent = self
+    #     ephemeral_children << o
+    #   else
+    #     self.add_child o
+    #     self.save
+    #     self.refresh
+    #   end
+    # end
+
+    def ephemeral_children
+      EphemeralObjectsChildren[identity] ||= []
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    # TODO: Implement a unit test for this
+    def <<(o)
+      return if o.nil?
+      return if o == self
+
+      if o.ephemeral?
+        o.parent = self
+        ephemeral_children << o
+      else
+        self.add_child o if self.respond_to?(:add_child)
+        o.parent_id = self.id if o.respond_to?(:parent_id=)
+        o.save_changes if o.respond_to?(:save_changes)
+        self.save
+        self.associations.delete(:children) if self.respond_to?(:associations)
+        self.refresh
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    def remove
+      self.parent.remove_child(self.id) if self.parent&.children&.include?(self)
+    rescue StandardError => e
+      log.error e
+    end
+
+    def empty?
+      return false if ephemeral_children.any?
+      return children_dataset.count.zero? if self.respond_to?(:children_dataset)
+
+      children.empty?
+    rescue StandardError => e
+      log.error "Unexpected error getting children count for #{self.class} #{self.id}: #{e.message}", $ERROR_INFO
+      children.empty?
+    end
+    # def empty?
+    #   begin
+    #     n = db.fetch("select count(*) from object where parent_id = #{self.id}").first[:count].to_i
+    #   rescue StandardError => e
+    #     log.error "Unexpected error getting children count for #{self.class} #{self.id}: #{e.message}", $ERROR_INFO
+    #     n = children.length
+    #   end
+    #   n == 0
+    # end
+
+    def child(o = nil)
+      return o.child unless o.nil?
+      return self.children_dataset.first if self.respond_to?(:children_dataset)
+
+      self.children.first
+    end
+
+    def location
+      linkto(:location) || self.parent
+    end
+
+    def list_together
+      linkto :list_together
+    end
+
+    def before_create
+      self.created_at ||= Time.now
+      super
+    end
+
+    def before_destroy
+      self.safe_refresh if self.respond_to? :safe_refresh
+      self.children.each { |x| x.destroy unless x.has? :prized }
+      super
+    end
+
+    def after_destroy
+      super
+    end
+
+    def after_save
+      super
+      self.modified_at = Time.now
+    end
+
+    def before_clone(copy); end
+
+    def after_clone(copy)
+      copy.untag :prized
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def clone
+      return if Session.players.include? self # Don't clone players.
+
+      data = self.values.dup
+      data.delete :id
+      data.delete :attributes
+      data.delete :properties
+      copy = self.class.new(data)
+      before_clone(copy) if respond_to? :before_clone
+      copy.properties = self.properties
+      copy.save
+      copy.untag(*copy.tags)
+      copy.tag(*self.tags)
+      copy.mod(*self.modules)
+      copy.link(:original, self)
+      self.children.each { |x| copy << x.clone }
+      after_clone(copy) if respond_to? :after_clone
+      copy
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def sysclone(klass = Inform::System::Object)
+      copy = klass.new self.short_name
+      copy.name = self.name
+      copy.properties[:source_id] = self.id
+      copy.properties = self.properties
+      copy.tags = self.nil_safe_tags
+      after_clone(copy) if respond_to? :after_clone
+      copy
+    end
+
+    ExportFileNameTemplate = '%<name>s-%<id>s.%<ext>s'.freeze
+    JsonOptions = {
+      include: %i[tagged modularized]
+    }.freeze
+
+    def export_json
+      return unless respond_to? :to_json
+
+      self.to_json(**JsonOptions).save(
+        format(ExportFileNameTemplate, name: self.to_s, id: self.id, ext: :json)
+      )
+    end
+
+    def export_yaml
+      return unless self.respond_to? :to_yaml
+
+      self.to_yaml.save(
+        format(ExportFileNameTemplate, name: self.to_s, id: self.id, ext: :yaml)
+      )
+    end
+
+    XmlOptions = {
+      except: :id,
+      include: {
+        tagged: {
+          except: :id
+        },
+        modularized: {
+          except: :id
+        }
+      }
+    }.freeze
+    XmlFileNameTemplate = '%<name>s-%<id>s.json'.freeze
+
+    def export_xml
+      return unless self.respond_to? :to_xml
+
+      self.to_xml(**XmlOptions).save(
+        format(ExportFileNameTemplate, name: self.to_s, id: self.id, ext: :xml)
+      )
+    end
+
+    def encode_with(coder)
+      %w[id name short_name description properties links modularized tagged].each do |v|
+        coder[v] = self.send(v) if self.respond_to? v
+      end
+    end
+
+    # def init_with(coder)
+    #   %w[ id name short_name description properties ].each do |v|
+    #     m = "#{v}=".to_sym
+    #     self.send(m, coder[v]) if self.respond_to? m
+    #   end
+    #   log.debug "Importing #{self.inspect}"
+    #   log.debug "Importing #{self.to_hash.inspect}"
+    #   log.debug " - #{(self.methods - ::Object.instance_methods).uniq.sort}"
+    #   self
+    # end
+  end
+  # rubocop: enable Metrics/ClassLength
+  # class Object
+end
+# module Inform
+
+# The ExtendedProperties class
+class ExtendedProperties < Inform::Object
+  def init
+    has :proper
+    super
+  end
+end

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

@@ -0,0 +1,152 @@
+# lib/story_teller/inform/relational/tag.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/>.
+
+# Tag
+
+if defined?(Sequel::Migration)
+# The TagSetup class
+class TagSetup < Sequel::Migration
+  def up
+    # return if table_exists? :tag
+    log.debug "#up"
+    create_table? :tag do
+      primary_key :id
+      index :name
+      index :created_at
+
+      String :name, unique: true, null: false
+      DateTime :created_at
+      DateTime :modified_at
+    end
+  end
+
+  def down
+    drop_table(:tag, cascade: true) if table_exists? :tag
+  end
+end
+# class TagSetup
+end
+# defined?(Sequel::Migration)
+
+# module Inform
+module Inform
+  # class Tag
+  class Tag < Sequel::Model
+    set_primary_key :id
+    def_column_accessor :created_at, :modified_at
+    def_column_accessor :name
+
+    def before_create
+      self.created_at ||= Time.now
+      super
+    end
+
+    def after_create
+      super
+      Inform.attributes.reset
+    end
+
+    def after_save
+      super
+      self.modified_at = Time.now.utc
+    end
+
+    def to_s
+      name
+    end
+    alias to_str to_s
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def self.tidy
+      db << %(delete from tag where id in
+(select a.id from tag a group by a.id, a.name
+having ((select count(b.id) from tagged b
+where b.tag_id = a.id) = 0)))
+      Inform.attributes.reset
+      return nil
+    end
+
+    # rubocop: disable Style/FormatStringToken
+    def self.dirty
+      results = db.fetch %(select a.id, a.name from tag a group by a.id, a.name having
+((select count(b.id) from tagged b where b.tag_id = a.id) = 0))
+      return nil if results.empty?
+      s = [format('%5s %20s', *results.first.keys)]
+      s.concat(results.collect { |row| format('%5d %20s', *row.values) })
+      s.join("\n")
+    end
+    # rubocop: enable Style/FormatStringToken
+
+    # rubocop: disable Style/FormatStringToken
+    def self.stats
+      results = db.fetch %(select a.*, count(a.id) as "number tagged"
+from tag a, tagged b where b.tag_id = a.id group by a.id, a.name)
+      return nil if results.empty?
+      s = [format('%5s %20s %15s', *results.first.keys)]
+      s.concat(results.collect { |row| format('%5d %20s %15s', *row.values) })
+      s.join("\n")
+    end
+    # rubocop: enable Style/FormatStringToken
+  end
+end
+# module Inform
+
+# module Inform
+module Inform
+  module_function
+
+  def tag_klass
+    Inform::Tag
+  end
+end
+
+# Tagged
+
+if defined?(Sequel::Migration)
+# The TaggedSetup class
+class TaggedSetup < Sequel::Migration
+  def up
+    log.debug "#up"
+    create_table? :tagged do
+      primary_key :id
+      foreign_key :object_id, :object, on_delete: :cascade
+      foreign_key :tag_id, :tag, on_delete: :cascade
+    end
+  end
+
+  def down
+    drop_table(:tagged, cascade: true) if table_exists? :tagged
+  end
+end
+# class TaggedSetup
+end
+# defined?(Sequel::Migration)
+
+# module Inform
+module Inform
+  # The Tagged class
+  class Tagged < Sequel::Model
+    set_primary_key :id
+  end
+end