inform-runtime 1.0.4

data/lib/runtime/object.rb

@@ -0,0 +1,761 @@
+# 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/>.
+
+# 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)
+  end
+end
+# class ObjectSetup
+end
+# defined?(Sequel::Migration)
+
+def Object(name, klass = Inform::Object, &block)
+  obj = klass.fetch_or_create_by_name(name)
+  obj.with(&block) if block_given?
+  obj.save_changes
+  obj
+end
+
+# The Inform module
+module Inform
+  unless defined?(Inform::SystemObjects)
+    SystemObjects = if defined?(Java)
+      java.util.concurrent.ConcurrentHashMap.new
+    else
+      {}
+    end
+  end
+
+  # The Inform::Object class
+  # rubocop: disable Metrics/ClassLength
+  class Object < Sequel::Model
+    logger
+    plugin :defaults_setter
+    plugin :dirty
+    plugin :rcte_tree
+    plugin :serialization
+    plugin :serialization_modification_detection
+    plugin :single_table_inheritance, :object_type
+    set_primary_key :id
+    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
+    # rubocop: disable Metrics/PerceivedComplexity
+    def initialize(*args, &block)
+      if args.empty?
+        if block_given?
+          super() { |obj| obj }
+        else
+          super()
+        end
+      elsif args.first.is_a?(String)
+        short_name = args.first
+        if block_given?
+          super(name: short_name, short_name: short_name) { |obj| obj }
+        else
+          super(name: short_name, short_name: short_name)
+        end
+      elsif block_given?
+        super { |obj| obj }
+      else
+        super(*args)
+      end
+      @tags_semaphore = Mutex.new
+      @semaphore = Mutex.new
+      self.with(&block) if block_given?
+      self.save_changes
+    end
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    def self.fetch_or_create_by_name(name)
+      db.transaction(savepoint: true) do
+        for_update.where(name: name).first || create(name: name, short_name: name)
+      end
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    def short_name(*args)
+      return (self.short_name = args.first) unless args.empty?
+      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_changes if self.respond_to?(:save_changes)
+        self.values[:short_name]
+      else
+        textual_name
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    def name(*args)
+      return args.first.object_name if args.first.respond_to?(:object_name)
+      return self[:name] if args.empty?
+      self[:name] = args.length > 1 ? args.join(' ') : args.first
+      self.save_changes if self.respond_to?(:save_changes)
+      self[:name]
+    end
+
+    def description(*args)
+      return self[:description] if args.nil? || args.empty?
+      self[:description] = args.length > 1 ? args.join(' ') : args.first
+      self.save_changes if self.respond_to?(:save_changes)
+      self[:description]
+    end
+
+    def object_name
+      self[:display_name] || self[:short_name] || self[:name]
+    end
+
+    def name_words
+      self.values[:name].split(/[,\s]+/).join(', ')
+    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.println(inflib.parse(s))
+      end
+    end
+
+    def invoke(a, *args)
+      return unless inflib
+      inflib.invoke(a, *args)
+    end
+
+    def _invoke(a, *args)
+      return unless inflib
+      inflib._invoke(a, *args)
+    end
+
+    def inflib
+      return Inform::Runtime.libraries[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 println(s, isolate: false)
+      inflib&.println(s, isolate: isolate)
+    end
+
+    def print(s, isolate: false)
+      inflib&.print(s, isolate: isolate)
+    end
+
+    Visited = defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {}
+    def visited
+      Visited[self] ||= []
+    end
+
+    def safe_refresh
+      self.refresh
+    rescue Sequel::NoExistingObject => e
+      log.warn "Object refresh failure: #{e.message}; ignoring"
+    end
+
+    def safe_save
+      self.save_changes if self.respond_to?(:save_changes)
+    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
+      Inform::Object[self.id]
+    end
+
+    def sys_children
+      SystemObjects[identity] ||= []
+    end
+
+    # def eql?(other)
+    #   self == other
+    # end
+
+    # def ==(other)
+    #   self === other
+    # end
+
+    # TODO: Implement a unit test for this
+    def <<(o)
+      return if o.nil?
+      return if o == self
+      if o.sysobj?
+        o.parent = self
+        sys_children << o
+      else
+        self.add_child o
+        self.save_changes if self.respond_to?(:save_changes)
+        self.refresh
+      end
+    end
+
+    def remove
+      self.parent.remove_child(self.id) if self.parent&.children&.include?(self)
+    rescue StandardError => e
+      log.error e
+    end
+
+    COUNT_FAIL_MESSAGE = 'Failed to count children for %<obj>s: %<message>s'.freeze
+
+    def empty?
+      self.class.where(parent_id: self.id).count.zero?
+    rescue StandardError => e
+      log.warn format(COUNT_FAIL_MESSAGE, obj: self.identity, message: e.message)
+      children_dataset.count.zero?
+    end
+
+    def child(o = nil)
+      o ? o.child : 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 after_create
+      super
+      index_words if self.respond_to?(:index_words)
+      init
+    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_initialize
+      super
+      apply_instance_behavior! if self.respond_to?(:apply_instance_behavior!)
+    end
+
+    def after_refresh
+      super
+      drain_deferred_with! if self.respond_to?(:drain_deferred_with!)
+      apply_instance_behavior! if self.respond_to?(:apply_instance_behavior!)
+    end
+
+    def after_load
+      super
+      drain_deferred_with! if self.respond_to?(:drain_deferred_with!)
+    end
+
+    def after_save
+      super
+      self.modified_at = Time.now
+    end
+
+    def before_save
+      super
+    end
+
+    def before_clone(copy); end
+
+    def after_clone(copy)
+      copy.untag :prized
+    end
+
+    def init
+      # A designer should implement this in a subclass if necessary
+    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.dup
+      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
+
+    # Create a clone of this object that is a
+    # non-persistent Inform::System::Object instead
+    def sysclone(klass = Inform::System::Object)
+      copy = klass.new(self.short_name)
+      copy.name = self.name
+      # TODO: Support children cloning (maybe shallow only)
+      copy.properties = self.properties.dup
+      copy.properties[:source_id] = self.id
+      copy.tags = self.nil_safe_tags
+      # TODO: Support modules
+      after_clone(copy) if respond_to?(:after_clone)
+      copy
+    end
+
+    ExportFileNameTemplate = '%<self>s-%<id>s.%<ext>'.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: :yml))
+    end
+
+    XmlOptions = {
+      except: :id,
+      include: {
+        tagged: {
+          except: :id
+        },
+        modularized: {
+          except: :id
+        }
+      }
+    }.freeze
+    XmlFileNameTemplate = '%<self>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 Inform::Object
+end
+# module Inform
+
+# The Inform module
+module Inform
+  # The Inform::System module
+  module System
+    # The Inform::System::Object class
+    # rubocop: disable Metrics/ClassLength
+    class Object
+      Instances = Struct.new(:memo).new(defined?(Java) ? java.util.concurrent.CopyOnWriteArrayList.new : [])
+      attr_accessor :short_name, :display_name, :inflib, :properties, :links,
+        :modules, :tags, :created_at, :modified_at, :visited
+
+      attr_writer :description
+
+      alias values properties
+
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/MethodLength
+      def initialize(textual_name = nil, *args, &block)
+        super(*args)
+        @name = textual_name || self.class.name
+        @short_name = textual_name || format('(%<short_name>s)', short_name: self.class.name)
+        @display_name = textual_name
+        @description = nil
+        @adjectives = []
+        @properties = {}
+        @links = []
+        @modules = []
+        @tags = []
+        @children = []
+        @visited = []
+        @created_at = @modified_at = Time.now
+        index_words if respond_to?(:index_words)
+        index_obj(self)
+        self.with(&block) if block_given?
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/MethodLength
+
+      def index_obj(obj)
+        if Instances.memo.respond_to?(:add)
+          Instances.memo.add(obj)
+        else
+          Instances.memo << obj
+        end
+      end
+
+      def self.all
+        Instances.memo.dup
+      end
+
+      def self.clear
+        Instances.memo.clear
+      end
+
+      def [](property)
+        return description if property == :description
+        return name if property == :name
+        return short_name if property == :short_name
+        properties[property]
+      end
+
+      def to_hash
+        properties.merge(
+          id: id,
+          name: name,
+          short_name: short_name,
+          description: description
+        )
+      end
+
+      def <=>(other)
+        self.name <=> other.name
+      end
+
+      def parse(s)
+        return if inflib.nil?
+        inflib.semaphore.synchronize do
+          inflib.println(inflib.parse(s))
+        end
+      end
+
+      def id
+        self.object_id
+      end
+
+      def object_type
+        self.class
+      end
+
+      def name(*args)
+        return args.first.object_name if args.first.respond_to?(:object_name)
+        return @name if args.empty?
+        @name = ([@name] | args).flatten.uniq
+        index_words if respond_to?(:index_words)
+        @name
+      end
+
+      def description(*args)
+        return @description if args.nil? || args.empty?
+        @description = args.length > 1 ? args.join(' ') : args
+        @description
+      end
+
+      def object_name
+        @display_name || @short_name || @name
+      end
+
+      def name_words
+        @name.split(/[,\s]+/).join(', ')
+      end
+
+      def <<(o)
+        return if self == o
+        return unless o.object?
+        o.parent = self
+        @children << o
+      end
+
+      def remove
+        @children.clear
+        @parent = nil
+      end
+
+      def empty?(*args, &block)
+        self.children.empty?(*args, &block)
+      end
+
+      def children(o = nil, prop = :@children)
+        return @children if o.nil?
+        return o.instance_variable_get(prop).length if o.instance_variable_defined?(prop)
+        o.children.length
+      end
+
+      # TODO: Remove if possible after unit test implementation
+      def location
+        self.parent
+      end
+
+      def list_together
+        linkto :list_together
+      end
+
+      def ancestors
+        self.parent.nil? ? [] : self.parent.ancestors + [self.parent]
+      end
+
+      def descendants
+        @children + @children.map(&:descendants).flatten
+      end
+
+      def root
+        self.parent.nil? ? self : self.parent.root
+      end
+
+      def parent(o = nil, &block)
+        return @parent if o.nil?
+        o.safe_refresh if o.respond_to? :safe_refresh
+        return unless o.respond_to? :parent
+        obj_parent = block_given? ? parent_selector(o, &block) : o.parent
+        return nil if obj_parent.nil?
+        obj_parent.safe_refresh if obj_parent.respond_to? :safe_refresh
+        obj_parent
+      end
+
+      # rubocop: disable Style/TrivialAccessors
+      def parent=(o)
+        @parent = o
+      end
+      # rubocop: enable Style/TrivialAccessors
+
+      def _set_object(link_name, obj = nil)
+        link(link_name, obj).to
+      end
+
+      def _get_object(link_name)
+        find_link(link_name)&.to
+      end
+
+      def find_link(link_name)
+        links.find { |x| x.name == link_name }
+      end
+
+      def link(link_name, obj = nil)
+        link = Inform::System::Link.new(name: link_name, to: obj, from: self)
+        links << link
+        link
+      end
+
+      def linked?(link_name)
+        links.count { |x| x.name == link_name } > 0
+      end
+      alias _key? linked?
+
+      def unlink(link_name)
+        links.delete_at(links.index { |x| x.name == link_name })
+      end
+      alias _unset_object unlink
+
+      def linkto(link_name)
+        _get_object(link_name)
+      end
+
+      def linksfrom(link_name = nil)
+        if link_name.nil?
+          links.select { |x| x.to == self }.map(&:from)
+        else
+          links.select { |x| x.name == link_name && x.to == self }.map(&:from)
+        end
+      end
+
+      def init
+        self
+      end
+      alias safe_init init
+
+      def refresh
+        self
+      end
+      alias safe_refresh refresh
+
+      def save(*_args)
+        self
+      end
+      alias safe_save save
+
+      def to_s
+        self.name
+      end
+
+      def inspect
+        identity
+      end
+    end
+    # rubocop: enable Metrics/ClassLength
+    # class Inform::System::Object
+
+    # The Inform::System::Link class
+    class Link
+      LinkTemplate = '%<link_name>s -> %<to_name>s [%<to_identity>s]'.freeze
+      attr_reader :name, :to, :from
+
+      def initialize(properties)
+        @name = properties[:name]
+        @to = properties[:to]
+        @from = properties[:from]
+      end
+
+      def to_s
+        format(LinkTemplate, link_name: name, to_name: to, to_identity: to.identity)
+      end
+    end
+  end
+  # module Inform::System
+end
+# module Inform
+
+# The Inform module
+# module Inform
+#   # The Inform::SingletonClassMethods module
+#   module SingletonClassMethods
+#     Registry = Class.new(Hash)
+#     SingletonRegistry = Registry.new
+
+#     def instance(object_name, **attrs, &block)
+#       key = object_name.nil? ? attrs.to_s : object_name
+#       attrs.merge!(name: object_name) unless object_name.nil?
+#       SingletonRegistry[key] ||= fetch_or_create(**attrs, &block)
+#     end
+
+#     # !rubocop: disable Metrics/MethodLength
+#     def fetch_or_create(**attrs, &block)
+#       db.transaction do
+#         entity = where(**attrs).first
+#         if entity.nil?
+#           entity = create(**attrs)
+#           entity.refresh
+#         end
+#         unless block.nil?
+#           block.call(entity)
+#           entity.save_changes if entity.changed_columns.any?
+#         end
+#         entity
+#       end
+#     end
+#     # !rubocop: enable Metrics/MethodLength
+#   end
+# end
+
+# The Inform module
+# module Inform
+#   # The Inform::SingletonObject class
+#   class SingletonObject < Inform::Object
+#     class << self
+#       include Inform::SingletonClassMethods
+#     end
+#   end
+# end
+
+# The ExtendedProperties class
+class ExtendedProperties < Inform::Object
+  def init
+    has :proper
+    super
+  end
+end