inform-runtime 1.0.4

data/lib/runtime/prototype.rb

@@ -0,0 +1,307 @@
+# 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 Inform::Prototypical module
+  module Prototypical
+    def context_event
+      Thread.current[:event]
+    end
+
+    def instance_variables_map
+      instance_variables.each_with_object({}) do |key, memo|
+        memo[key] = instance_variable_get(key)
+      end
+    end
+
+    def values
+      super || instance_variables_map
+    rescue StandardError => e
+      log.warn "Unexpected error invoking super(Inform::Prototypical#values): #{e.message}"
+      instance_variables_map
+    end
+
+    def string?(key)
+      v = self.&key
+      return false if v.nil?
+      v.respond_to?(:to_s) && !v.to_s.empty?
+    end
+
+    MethodWriterTemplate = '%<method_name>s='.freeze
+
+    # This method tries to access or write values given by *args
+    # to the property using an accessor or writer method, and
+    # failing that, will invoke the prototype method, which
+    # dynamically defines an accessor or writer method on the
+    # receiver for future ease of access.
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/BlockNesting
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def &(property, *args)
+      return nil if property.nil?
+      return super unless property.is_a?(Symbol) || property.is_a?(String)
+      return nil if property.respond_to?(:empty?) && property.empty?
+      property, sub_property = property.to_s.split('.').map(&:to_sym)
+      if !args.empty?
+        setter = format(MethodWriterTemplate, method_name: property)
+        if !sub_property.nil?
+          value = self.send(property)
+          if value.object?
+            value.&(sub_property, *args)
+          elsif value.respond_to?(:key?)
+            value[sub_property] = (args.length > 1 ? args : args.first)
+            self.send(setter, value)
+          else
+            self.send(setter, *args)
+          end
+        elsif self.respond_to?(property) && args.length == self.method(property).arity
+          self.send(property, *args)
+        elsif self.respond_to?(setter) && args.length == self.method(setter).arity
+          self.send(setter, *args)
+        elsif !Kernel.methods.include?(property)
+          self.send(property, *args)
+        else
+          self.prototype(property, *args)
+        end
+      elsif !sub_property.nil?
+        value = self.send(property)
+        if value.object?
+          value.&(sub_property, *args)
+        elsif value.respond_to?(property)
+          value.send(property)
+        elsif value.respond_to?(:key?)
+          value[sub_property]
+        else
+          value
+        end
+      elsif self.respond_to?(property)
+        self.send(property)
+      elsif (self.properties.respond_to?(:key?) && self.properties.key?(property)) ||
+          (self.respond_to?(:_key?) && self._key?(property))
+        self.prototype(property)
+      else
+        return nil
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/BlockNesting
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    # This method attempts to get a value if it exists.
+    # If no value is already set on the receiver, any given
+    # arguments will be set on the receiver for future access.
+    def |(property, *args)
+      return nil if property.nil?
+      return super unless property.respond_to?(:to_s)
+      return nil if property.to_s.empty?
+      v = self.&property
+      v || send(property, *args)
+    end
+
+    VariableTemplate = '@%<property>s'.freeze
+    MethodBooleanOrBangPattern = %r{([\?!]+)$}.freeze
+    MethodWriterPattern = %r{=$}.freeze
+    LinkPattern = %r{.+_to$}.freeze
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    # rubocop: disable Style/MissingRespondToMissing
+    def method_missing(method, *args, &block)
+      return super if method == :to_ary
+      m = method.to_s
+      return super if MethodBooleanOrBangPattern.match?(m)
+      mname = MethodWriterPattern.match?(m) ? m.chop : m
+      property = mname.to_sym
+      variable = format(VariableTemplate, property: property).to_sym
+      event = context_event
+
+      if MethodWriterPattern.match?(m) || (LinkPattern.match?(m) && !args.empty?)
+        if !event.nil? && Inform::Runtime.invocation_properties.include?(property)
+          event.send(method, *args, &block)
+        elsif inflib&.library_method?(method)
+          inflib.send(method, *args, &block)
+        else
+          self.prototype(method, *args, &block)
+        end
+      elsif !event.nil? && Inform::Runtime.invocation_properties.include?(property)
+        result = event.send(method, *args, &block)
+        log.debug("Value for event #{event}.#{method} is: #{result || 'nil'}") if defined? DEBUG
+        result
+      elsif inflib&.library_method?(method)
+        inflib.send(method, *args, &block)
+      elsif inflib.respond_to?(method) && Inform::Runtime.invocation_properties.include?(property)
+        inflib.send(method, *args, &block)
+      elsif inflib&.instance_variable_get(variable) || inflib&.instance_variables&.include?(variable)
+        inflib.instance_variable_get(variable)
+      elsif (properties.respond_to?(:key?) && properties.key?(property)) ||
+          (respond_to?(:_key?) && _key?(property)) ||
+          !args.empty?
+        self.prototype(method, *args, &block)
+      else
+        super
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+    # rubocop: enable Style/MissingRespondToMissing
+
+    # def respond_to_missing?(method, include_all=false)
+    #   m = method.to_s
+    #   return false if m =~ /\?$/
+    #   mname = m =~ /\=$/ ? m.chop : m
+    #   property = mname.intern
+    #   Inform::Runtime.invocation_properties.include? property
+    # end
+
+    def accessor_and_writer(key)
+      return [key.to_s.chop, key] if MethodWriterPattern.match?(key)
+      [key, format(MethodWriterTemplate, method_name: key)]
+    end
+
+    AccessorMethodTemplate = %(
+    def %<accessor>s(*args)
+      args.empty? ? self._get(__method__) : self._set(__method__, *args)
+    end
+    ).freeze
+
+    WriterMethodTemplate = %(
+    def %<writer>s(value)
+      self._assign(__method__.to_s.chop.to_sym, value)
+    end
+    ).freeze
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    def prototype(key, *args, &block)
+      ensure_properties_attribute!
+      accessor, writer = accessor_and_writer(key)
+      if key_refers_to_link?(key)
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        if args.empty? && self.properties.key?(key)
+          return if (to_obj = get_constant(self.properties[key])).nil? || !to_obj.object?
+          self.link(key, to_obj)
+          self.properties.delete(key)
+          self.save_changes if self.respond_to?(:save_changes)
+          return to_obj
+        end
+        self.properties[key] = args.first
+      end
+      accessor = format(AccessorMethodTemplate, accessor: accessor)
+      self.instance_eval(accessor, __FILE__, __LINE__)
+      writer = format(WriterMethodTemplate, writer: writer)
+      self.instance_eval(writer, __FILE__, __LINE__)
+      self.send(key, *args, &block)
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+
+    MISSING_PROPERTIES_MESSAGE = 'Missing properties attribute for: ' \
+      '%<identity>s'.freeze
+
+    def ensure_properties_attribute!
+      return unless self.properties.nil?
+      raise StandardError, format(MISSING_PROPERTIES_MESSAGE, identity: self.identity)
+    end
+
+    def key_refers_to_link?(key)
+      Inform::Library::DeclaredProperties.memo.key?(key) && LinkPattern.match?(key.to_s)
+    end
+
+    def _get(key)
+      result = nil
+      result = self._get_object(key) if self.respond_to?(:_key?) && self._key?(key)
+      result || self.properties.dup[key]
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def _set(key, *values)
+      raise "The key parameter must be a symbol" unless key.is_a? Symbol
+      raise "The values parameter may not be empty" if values.empty?
+      result = nil
+      if values.first.object?
+        result = self._set_object(key, values.first) if respond_to? :_set_object
+      elsif values.first.nil? && self.respond_to?(:_key?) && self._key?(key)
+        result = self._unset_object(key) if self.respond_to?(:_unset_object)
+      elsif values.first.nil?
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties.delete(key)
+        self.save_changes if self.respond_to?(:save_changes)
+      elsif values.length > 1
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties[key] = []
+        self.properties[key].concat(values)
+        values.clear
+        self.save_changes if self.respond_to?(:save_changes)
+      else
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties[key] = values.first
+        self.save_changes if self.respond_to?(:save_changes)
+      end
+      result || self.properties.dup[key]
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def _assign(key, value)
+      raise "The key parameter must be a symbol" unless key.is_a? Symbol
+      result = nil
+      if value.object?
+        result = self._set_object(key, value) if self.respond_to?(:_set_object)
+      elsif value.nil? && self.respond_to?(:_key?) && self._key?(key)
+        result = self._unset_object(key) if self.respond_to?(:_unset_object)
+      elsif value.nil? && self.properties.key?(key)
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties.delete(key)
+        self.save_changes if self.respond_to?(:save_changes)
+      else
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties[key] = value
+        self.save_changes if self.respond_to?(:save_changes)
+      end
+      result || self.properties.dup[key]
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+  end
+  # module Prototypical
+end
+# module Inform

data/lib/runtime/publication.rb

@@ -0,0 +1,92 @@
+# 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 'subscription'
+
+# The Inform module
+module Inform
+  # The Publisher module to implement rudimentary pub-sub functionality
+  module Publisher
+    include Inform::Subscribers
+
+    def muted?
+      false
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/PerceivedComplexity
+    def subscribers
+      safe_refresh if respond_to?(:safe_refresh)
+      root_obj = attempt_twice { root } if self.respond_to?(:root) # TODO: FIXME
+      return explicit_subscribers.dup if root_obj.nil?
+      eavesdroppers = (root_obj&.safe_refresh&.branch || []) - [self]
+      # explicit_subscribers + (eavesdroppers & Session.players) # TODO: FIXME
+      players = defined?(Session) ? Session.players.dup : []
+      explicit_subscribers + eavesdroppers.each_with_object([]) do |o1, memo|
+        memo.concat(players.select { |o2| o1 == o2 })
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    def publish_only(message, *args, &condition)
+      return if muted?
+      (subscribers & args.flatten).each do |subscriber|
+        next if block_given? && !condition.call(subscriber)
+        subscriber.update(message)
+      end
+      false
+    end
+
+    def publish_except(message, *args, &condition)
+      return if muted?
+      (subscribers - args.flatten).each do |subscriber|
+        next if block_given? && !condition.call(subscriber)
+        log.warn "publishing message (#{message}) to subscriber: #{subscriber}"
+        subscriber.update(message)
+      end
+      false
+    end
+
+    # For system messages (to the InformLibrary, mainly)
+    def publish_system_message(message, *args, &condition)
+      subscribers.each do |subscriber|
+        next if block_given? && !condition.call(subscriber, *args)
+        subscriber.send(message, *args) if subscriber.respond_to?(message)
+      end
+      false
+    end
+
+    def publish(message, *args, &condition)
+      return publish_system_message(message, *args, &condition) if message.is_a?(Symbol)
+      return if muted?
+      subscribers.each do |subscriber|
+        next if block_given? && !condition.call(subscriber)
+        # log.info "#{subscriber.name}#update message: #{message.inspect}"
+        subscriber.update(message, *args)
+      end
+      false
+    end
+  end
+  # module Publisher
+end
+# module Inform