inform-runtime 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f79733e3acaea7ef29ef54048e40496a2e59f4eb3e367369cfadfc7a9ac1e7a
-  data.tar.gz: 60560e1801f0489cf40b6144adb7ec5618d0bbb265f3304ea59d1837e61bd379
+  metadata.gz: 8342db25700d881e383905faaf8c8d3029511a245b9cc1e4b49aec3ebf6a0149
+  data.tar.gz: dece3144963ca7775f4b8367047a30a883dbdaefe68df0e689a5f1f9a0482089
 SHA512:
-  metadata.gz: 154bb199c8b4de11899a9206abe0805b71a8a678c62dac81fbb326de36d7f2092f7b70c14702403dab7ae45752ea647fb012d941498d554d7196d9f6cd651562
-  data.tar.gz: 4000a694bde0d03cd6a88b7959f2e451fb2935cc8468330a6fbbcb8408696e30a1cde5912da28289a5a35c9027eca75c52cbb952a0d408cb64e8a30a4727573a
+  metadata.gz: 5142ffd42f10634c007b7aa945bd68b1d653331be622bac0b83051ed9e57d64e8bd7d190954ac42c642b7208aad9eb2fa99f20f2355c1d3c2516a493d152dca2
+  data.tar.gz: ebda0189c7b38d24a1d02719756c7c5e5c7ab0c1384b33c19112636c764ad15e8aab22273fd7cf38afdf28543034a1b85fdc5baf0eeb9bb6aae6c0a387c04ace

data/Rakefile

@@ -23,24 +23,6 @@ CLOBBER.add '*.gem', 'pkg'
 
 task default: %i[package]
 
-desc 'Archive the current codebase snapshot'
-task :archive do
-  repo_path = '.'
-  archive = File.expand_path(File.join('..', "#{StoryTeller::PROJECT}.zip"), Dir.pwd)
-
-  diff_clean = system('git', '-C', repo_path, 'diff-index', '--quiet', 'HEAD', '--')
-  untracked = `git -C #{repo_path.shellescape} ls-files --others --exclude-standard`
-
-  unless diff_clean && untracked.empty?
-    warn 'Please resolve uncommitted or untracked changes in working tree.'
-    exit 1
-  end
-
-  FileUtils.rm_f(archive)
-
-  system('git', '-C', repo_path, 'archive', '-o', archive, '--format=zip', 'HEAD') or abort
-end
-
 desc 'Run the rubocop linter'
 task :lint do
   system('bundle', 'exec', 'rubocop') or abort
@@ -63,6 +45,7 @@ task :verify do
   system('bundle', 'exec', 'rspec', 'spec/verify_gem_spec.rb') or abort
   system('bundle', 'exec', 'rake', 'clean')
 end
+task verify: :package
 
 desc 'Publish the gem'
 task :publish do

data/lib/story_teller/command.rb

@@ -85,6 +85,8 @@ module PublicCommandMethods
 
   def cancelled?
     return true if future.nil?
+    return false unless future.respond_to?(:cancelled?)
+
     future.cancelled?
   end
 

data/lib/story_teller/core.rb

@@ -33,6 +33,7 @@ require_relative 'helpers'
 require_relative 'io'
 require_relative 'publication'
 require_relative 'context'
+require_relative 'privileges'
 require_relative 'world_tree'
 require_relative 'library'
 require_relative 'engine'

data/lib/story_teller/engine.rb

@@ -33,7 +33,7 @@ module StoryTeller
     module Library
       def play
         log.debug "Using engine-managed InformLibrary play method override"
-        inform_library = StoryTeller::Engine.libraries[StoryTeller::Engine]
+        inform_library = StoryTeller::Engine.library
         inform_library.play
         inform_library
       end
@@ -61,6 +61,46 @@ module StoryTeller
       @libraries ||= {}
     end
 
+    def library
+      selfobj = parser_selfobj
+      return libraries[selfobj] if !selfobj.nil? && libraries.key?(selfobj)
+
+      bind_managed_library(InformLibrary.new)
+    end
+
+    def bind_managed_library(inform_library)
+      raise ManagedLibraryError, "InformLibrary is nil" if inform_library.nil?
+
+      selfobj = inform_library.selfobj
+      raise ManagedLibraryError, "InformLibrary selfobj is nil" if selfobj.nil?
+
+      libraries[selfobj] = inform_library
+      selfobj.inflib = inform_library if selfobj.respond_to?(:inflib=)
+
+      ensure_location(inform_library)
+
+      inform_library
+    end
+
+    def ensure_location(inflib)
+      return if inflib.nil?
+
+      existing_location = inflib.instance_variable_get(:@location)
+      return unless existing_location.nil?
+
+      player = inflib.selfobj
+      location = player.location if player.respond_to?(:location)
+      location ||= player.spawn_point if player.respond_to?(:spawn_point)
+
+      inflib.instance_variable_set(:@location, location) unless location.nil?
+    end
+
+    def parser_selfobj
+      return nil unless defined?(Inform::Parser::SelfObj)
+
+      Inform::Parser::SelfObj
+    end
+
     def main_object=(obj)
       @main_object = obj
     end
@@ -130,17 +170,6 @@ module StoryTeller
     end
   end
   # module Engine
-
-  # The StoryTeller::Privileges module to implement privilege
-  module Privileges
-    def admin?
-      self.has?(:admin)
-    end
-
-    def builder?
-      admin? || self.has?(:builder)
-    end
-  end
 end
 # module StoryTeller
 

data/lib/story_teller/events.rb

@@ -113,7 +113,11 @@ module PublicEventMethods
   end
 
   def <<(event)
-    @successors.add event
+    if @successors.respond_to?(:add)
+      @successors.add(event)
+    else
+      @successors << event
+    end
     event.antecedent = self
   end
 
@@ -141,6 +145,8 @@ module PublicEventMethods
 
   def cancelled?
     return true if future.nil?
+    return false unless future.respond_to?(:cancelled?)
+
     future.cancelled?
   end
 
@@ -752,6 +758,7 @@ module Inform
       Inform::Events.each(event_class) do |event|
         # Do not artificially terminate the source of an interruption.
         next if event == interruption
+        next unless event.future.respond_to?(:cancel)
 
         # Parameterizing Future#cancel with false is supposed to
         # abort the future without interrupting the executing thread.

data/lib/story_teller/helpers.rb

@@ -148,20 +148,6 @@ module Inform
   end
 end
 
-# # The Inform module
-# module Inform
-#   # The ObjectHelpers module functionality
-#   module ObjectHelpers
-#     def object?(obj = self)
-#       obj.is_a?(Inform::Object) || obj.is_a?(Inform::Ephemeral::Object)
-#     end
-
-#     def sysobj?(obj = self)
-#       obj.is_a?(Inform::Ephemeral::Object)
-#     end
-#   end
-# end
-
 # The Inform module
 module Inform
   # The NilClassObjectHelpers module functionality

data/lib/story_teller/history.rb

@@ -1,3 +1,4 @@
+# lib/story_teller/history.rb
 # encoding: utf-8
 # frozen_string_literal: false
 

data/lib/story_teller/kernel.rb

@@ -176,17 +176,23 @@ module Kernel
 
   raise MethodAlreadyDefined, :class_loader if respond_to?(:class_loader)
   def class_loader
-    JRuby.runtime.jruby_class_loader
+    return JRuby.runtime.jruby_class_loader if defined?(JRuby)
+
+    raise NotImplementedError, "class_loader is only available on JRuby"
   end
 
   raise MethodAlreadyDefined, :load_service if respond_to?(:load_service)
   def load_service
-    JRuby.runtime.load_service
+    return JRuby.runtime.load_service if defined?(JRuby)
+
+    raise NotImplementedError, "load_service is only available on JRuby"
   end
 
   raise MethodAlreadyDefined, :object_space if respond_to?(:object_space)
   def object_space
-    JRuby.runtime.object_space
+    return JRuby.runtime.object_space if defined?(JRuby)
+
+    raise NotImplementedError, "object_space is only available on JRuby"
   end
 
   JavaPattern = %r{java}.freeze
@@ -205,6 +211,8 @@ module Kernel
   raise MethodAlreadyDefined, :collect_garbage if respond_to?(:collect_garbage)
   # rubocop: disable Metrics/AbcSize
   def collect_garbage
+    return unless java?
+
     java.lang.System.gc()
     sleep 0.1
     java.lang.System.runFinalization()

data/lib/story_teller/library/bootstrap.rb

@@ -27,37 +27,20 @@ module StoryTeller
     module Bootstrap
       module_function
 
-      def ensure_location(inflib)
-        return if inflib.nil?
-        return if inflib.location
+      def manage_inform_library(player: nil)
+        existing = StoryTeller::Engine.libraries[player] unless player.nil?
+        return existing unless existing.nil?
 
-        player_obj = inflib.player
-        location = player_obj&.location
-        location ||= player_obj&.spawn_point if player_obj.respond_to?(:spawn_point)
-        inflib.instance_variable_set(:@location, location)
+        new_inform_library(player:)
       end
 
-      def set_selfobj(inflib, player)
-        inflib.selfobj = player unless player.nil?
-      end
-
-      # rubocop: disable Metrics/MethodLength
-      def manage_inform_library(player: nil, key: StoryTeller::Engine, &block)
-        inflib = StoryTeller::Engine.libraries[key]
-        unless inflib.nil? || player.nil?
-          set_selfobj(inflib, player)
-          return inflib
-        end
-
-        inflib = block_given? ? block.call : InformLibrary.new
-        return nil if inflib.nil?
-
-        set_selfobj(inflib, player)
+      def new_inform_library(player: nil)
+        inflib = InformLibrary.new
+        bind_inform_library(inflib, player)
         inflib.subscribe(inflib.selfobj)
         ensure_location(inflib)
-        StoryTeller::Engine.libraries[key] = inflib
+        inflib
       end
-      # rubocop: enable Metrics/MethodLength
     end
     # module Bootstrap
   end

data/lib/story_teller/library/loader.rb

@@ -38,13 +38,14 @@ module StoryTeller
         InformLibrary.class_eval do
           include Inform::Context unless include?(Inform::Context)
           include Inform::StdLib unless include?(Inform::StdLib)
+          include Inform::History unless include?(Inform::History)
         end
         InformLibrary.prepend(StoryTeller::Library::Location)
       end
 
       def load_library
         augment_inform_library!
-        StoryTeller::Library::Bootstrap.manage_inform_library
+        StoryTeller::Engine.library
       end
 
       def inform_object_model?

data/lib/story_teller/logging.rb

@@ -26,26 +26,29 @@ if defined?(Java)
 require 'apache-log4j-2'
 end
 
-# The Logging module
-module Logging
+# The LoggingConfiguration module
+module LoggingConfiguration
+  # rubocop: disable Metrics/AbcSize
   # rubocop: disable Metrics/MethodLength
   def config
     @config ||= begin
-      support_dir_path = File.expand_path(__dir__)
-      lib_dir_path = File.expand_path(File.dirname(support_dir_path))
+      module_dir_path = File.expand_path(__dir__)
+      lib_dir_path = File.expand_path(File.dirname(module_dir_path))
       project_dir_path = File.expand_path(File.dirname(lib_dir_path))
       app_name = File.basename(project_dir_path)
       logs_dir_path = File.expand_path(File.join(project_dir_path, 'logs'))
       FileUtils.mkdir_p(logs_dir_path)
-      log_file = File.expand_path(File.join(logs_dir_path, "#{app_name}.log"))
+      log_file_path = File.expand_path(File.join(logs_dir_path, "#{app_name}.log"))
+      FileUtils.touch(log_file_path)
       {
-        level: :info,
+        level: ENV['INFORM_LOG_LEVEL']&.to_i || Logger::INFO,
         name: app_name,
         lib_dir_path: lib_dir_path,
         project_dir_path: project_dir_path,
         logs_dir_path: logs_dir_path,
-        log_file: log_file,
-        rolling_log_file_name_template: "#{app_name}-%d{yyyy-MM-dd}.log.gz",
+        log_file_path: log_file_path,
+        rolling_log_file_name_template: File.expand_path(
+          File.join(logs_dir_path, "#{app_name}-%d{yyyy-MM-dd}.log.gz")),
         logging_timestamp_format: '%Y-%m-%d %H:%M:%S',
         logging_pattern_template: {
           java: '%d{ABSOLUTE} %-5p [%c{1}] %m%n',
@@ -57,103 +60,182 @@ module Logging
     end
   end
   module_function :config
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+end
+
+# The LoggingHelpers module
+module LoggingHelpers
+  if defined?(Java)
+  java_import Java::org.apache.logging.log4j.core.appender::ConsoleAppender
+  java_import Java::org.apache.logging.log4j.core.config::Configurator
+  java_import Java::org.apache.logging.log4j.core.config.builder.api::ConfigurationBuilderFactory
+  java_import Java::org.apache.logging.log4j::Level
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
+    java.lang::System.setProperty('log4j.shutdownHookEnabled', java.lang::Boolean.toString(false))
+    config = ConfigurationBuilderFactory.newConfigurationBuilder()
+
+    log_level = Level.to_level(log_level.to_s.upcase) if log_level.is_a? Symbol
+    config.setStatusLevel(log_level)
+    config.setConfigurationName(LoggingConfiguration.config[:name])
+
+    # create a console appender
+    target = ConsoleAppender::Target::SYSTEM_OUT
+    pattern = LoggingConfiguration.config[:logging_pattern_template][:java]
+    layout = config.newLayout('PatternLayout')
+    layout = layout.addAttribute('pattern', pattern)
+    appender = config.newAppender('stdout', 'CONSOLE')
+    appender = appender.addAttribute('target', target)
+    appender = appender.add(layout)
+    config.add(appender)
+
+    # create a root logger
+    root_logger = config.newRootLogger(log_level)
+    root_logger = root_logger.add(config.newAppenderRef('stdout'))
+
+    # create a rolling file appender
+    cron = config.newComponent('CronTriggeringPolicy')
+    cron = cron.addAttribute('schedule', '0 0 0 * * ?')
+
+    size = config.newComponent('SizeBasedTriggeringPolicy')
+    size = size.addAttribute('size', LoggingConfiguration.config[:size])
+
+    policies = config.newComponent('Policies')
+    policies = policies.addComponent(cron)
+    policies = policies.addComponent(size)
+
+    appender = config.newAppender('rolling_file', 'RollingFile')
+    appender = appender.addAttribute(
+      'fileName', LoggingConfiguration.config[:log_file_path])
+    appender = appender.addAttribute(
+      'filePattern', LoggingConfiguration.config[:rolling_log_file_name_template])
+    appender = appender.add(layout)
+    appender = appender.addComponent(policies)
+    config.add(appender)
+
+    root_logger = root_logger.addAttribute('additivity', false)
+    root_logger = root_logger.add(config.newAppenderRef('rolling_file'))
+    config.add(root_logger)
+
+    logging_configuration = config.build()
+    ctx = Configurator.initialize(logging_configuration)
+    ctx.updateLoggers()
+  end
+  module_function :init_log4j
+  # rubocop: enable Metrics/AbcSize
   # rubocop: enable Metrics/MethodLength
+  # def init_log4j
+
+  LoggingHelpers.init_log4j if defined?(Java)
 end
+# module Logging
 
 # Namespace for methods to help with implicit backtrace printing
-module LoggerHelpers
+module TraceHelpers
   def generate_message(error_or_message, error)
     error_message = "#{error_or_message}: #{error.class.name}"
     error_message << ": #{error.message}" if error.respond_to?(:message)
     error_message
   end
+  module_function :generate_message
 
   def extract_backtrace(error, default_result = nil)
     if error.respond_to?(:backtrace)
-      error.backtrace.each { |trace| original_error(trace) unless trace.nil? }
+      error.backtrace || default_result
     elsif error.respond_to?(:getStackTrace)
-      error.getStackTrace().each { |trace| original_error(trace) unless trace.nil? }
+      error.getStackTrace() || default_result
     else
       default_result
     end
   end
+  module_function :extract_backtrace
 end
 
-# Monkey-patch the built-in Ruby Logger class to support
-# implicit backtrace printing
-# TODO: Figure out if this is actually useful.
+# class Logger
 class Logger
-  TRACE = DEBUG - 1 unless const_defined?(:TRACE)
-
-  include LoggerHelpers
+  # module Severity
+  module Severity
+    # Lowest-level information, for developers.
+    TRACE = -1
+    LEVELS['trace'] = Logger::Severity::TRACE
+  end
+end
 
+# Add extra severity to the standard Logger class.
+# Also add support for including backtraces implicitly.
+class ExtraLogger < Logger
   alias original_error error
+  def error(error_or_message = nil, error = nil, &block)
+    return log_error(error_or_message, &block) if error.nil?
 
-  def error(error_or_message, error = nil)
-    warn error_or_message
-    return extract_backtrace(error_or_message) if error.nil?
-    original_error(generate_message(error_or_message, error))
-    extract_backtrace(original_error(error))
+    original_error(TraceHelpers.generate_message(error_or_message, error))
+    TraceHelpers.extract_backtrace(error, []).each do |trace|
+      original_error(trace) unless trace.nil?
+    end
   end
 
-  def trace(progname = nil, &block)
-    add(TRACE, nil, progname, &block)
+  def log_error(error_or_message = nil, &block)
+    original_error(error_or_message, &block)
+    TraceHelpers.extract_backtrace(error_or_message, []).each do |trace|
+      original_error(trace) unless trace.nil?
+    end
   end
 
-  def trace?
-    @level <= TRACE
+  SEV_LABEL_EXTRA = (Logger::SEV_LABEL + %w(TRACE)).freeze
+  def format_severity(severity)
+    SEV_LABEL_EXTRA[severity] || super
+  end
+
+  def trace(progname = nil, &block)
+    add(Logger::Severity::TRACE, nil, progname, &block)
   end
 end
 
-# The Logging module
-module Logging
+# The LoggingHelpers module
+module LoggingHelpers
   if defined?(Java)
   java_import Java::org.apache.logging.log4j.Level
   java_import Java::org.apache.logging.log4j.LogManager
   end
 
-  RubyLogLevels = {
-    all: -Float::INFINITY,
-    trace: Logger::TRACE,
-    debug: Logger::DEBUG,
-    info: Logger::INFO,
-    warn: Logger::WARN,
-    error: Logger::ERROR,
-    fatal: Logger::FATAL,
-    unknown: Logger::UNKNOWN,
-    off: Logger::UNKNOWN + 1
-  }.freeze
+  FORWARD_SLASH_PATTERN = %r{/} unless defined?(FORWARD_SLASH_PATTERN)
 
-  def init_logger(level = :info, logger_name = nil)
-    return init_java_logger(level, logger_name, caller[2]) if defined?(Java)
-    init_ruby_logger(level, logger_name, caller[2])
+  def init_logger(obj, level = :info, logger_name = nil)
+    return init_java_logger(obj, level, logger_name, caller[2]) if defined?(Java)
+    init_ruby_logger(obj, level, logger_name, caller[2])
   end
+  module_function :init_logger
 
-  def ruby_log_formatter(severity, datetime, progname, message)
+  def ruby_log_formatter(severity_level, datetime, program_name, message)
     format(
-      Logging.config[:logging_pattern_template][:ruby],
-      timestamp: datetime.strftime(Logging.config[:logging_timestamp_format]),
-      progname: progname, severity: severity, msg: message)
+      LoggingConfiguration.config[:logging_pattern_template][:ruby],
+      timestamp: datetime.strftime(LoggingConfiguration.config[:logging_timestamp_format]),
+      progname: program_name, severity: severity_level, msg: message)
   end
+  module_function :ruby_log_formatter
 
-  ForwardSlashPattern = %r{/}.freeze
-
-  def init_ruby_logger(level = nil, logger_name = nil, source_location = nil)
-    logger_name = get_formatted_logger_name(logger_name)
-    logger_name = source_location.split(ForwardSlashPattern).last if logger_name.empty?
-    log = Logger.new($stdout, progname: logger_name)
+  def init_ruby_logger(obj, level = nil, logger_name = nil, source_location = nil)
+    logger_name = get_formatted_logger_name(obj, logger_name)
+    logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
+    log = ExtraLogger.new($stdout, progname: logger_name)
     log.level = normalize_ruby_log_level(level) unless level.nil?
     log.formatter = method(:ruby_log_formatter)
     log
   end
+  module_function :init_ruby_logger
 
-  def init_java_logger(level = nil, logger_name = nil, source_location = nil)
-    logger_name = get_formatted_logger_name(logger_name)
-    logger_name = source_location.split(ForwardSlashPattern).last if logger_name.empty?
+  def init_java_logger(obj, level = nil, logger_name = nil, source_location = nil)
+    logger_name = get_formatted_logger_name(obj, logger_name)
+    logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
     log = LogManager.getLogger(logger_name)
     log.level = Level.to_level(level.to_s.upcase) unless level.nil?
     log
   end
+  module_function :init_java_logger
 
   def normalize_ruby_log_level(level)
     return level if level.is_a?(Integer)
@@ -162,12 +244,26 @@ module Logging
       raise ArgumentError, "Unknown Ruby log level: #{level.inspect}"
     end
   end
+  module_function :normalize_ruby_log_level
 
-  def get_formatted_logger_name(logger_name = nil)
-    return logger_name.to_s[/\w+$/] unless logger_name.nil?
-    return name[/\w+$/] if is_a?(Class) || is_a?(Module)
-    self.class.name[/\w+$/]
+  def get_formatted_logger_name(obj, logger_name = nil)
+    return logger_name.to_s if !logger_name.nil? && logger_name.respond_to?(:to_s)
+    return obj.name if obj.is_a?(Class) || obj.is_a?(Module)
+    obj.class.name
   end
+  module_function :get_formatted_logger_name
+
+  RubyLogLevels = {
+    all: -Float::INFINITY,
+    trace: Logger::TRACE,
+    debug: Logger::DEBUG,
+    info: Logger::INFO,
+    warn: Logger::WARN,
+    error: Logger::ERROR,
+    fatal: Logger::FATAL,
+    unknown: Logger::UNKNOWN,
+    off: Logger::UNKNOWN + 1
+  }.freeze
 
   # rubocop: disable Metrics/CyclomaticComplexity
   # OFF: 0
@@ -191,23 +287,25 @@ module Logging
     when -Float::INFINITY..-2 then :all
     end
   end
+  module_function :symbolize_numeric_log_level
   # rubocop: enable Metrics/CyclomaticComplexity
+end
+# module LoggingHelpers
 
+# The Logging module
+module Logging
   def log_level=(level)
-    raise "Parameter level may not be nil" if level.nil?
-    normalized_level = symbolize_numeric_log_level(level)
-
-    Logging.config[:level] = normalized_level
+    LoggingConfiguration.config[:level] = LoggingHelpers.symbolize_numeric_log_level(level)
   end
   module_function :log_level=
 
   def log_level
-    Logging.config[:level]
+    LoggingConfiguration.config[:level]
   end
   module_function :log_level
 
-  def log(level = Logging.log_level, log_name = Logging.config[:app_name])
-    @log ||= init_logger(level, log_name)
+  def log(level = Logging.log_level, log_name = LoggingConfiguration.config[:app_name])
+    @log ||= LoggingHelpers.init_logger(self, level, log_name)
   end
   alias logger log
 end

data/lib/story_teller/privileges.rb

@@ -0,0 +1,34 @@
+# lib/story_teller/privileges.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/>.
+
+# The StoryTeller module
+module StoryTeller
+  # The StoryTeller::Privileges module to implement privilege
+  module Privileges
+    def admin?
+      self.has?(:admin)
+    end
+
+    def builder?
+      admin? || self.has?(:builder)
+    end
+  end
+end

data/lib/story_teller/prototype.rb

@@ -162,6 +162,13 @@ module Inform
           (respond_to?(:_key?) && _key?(property)) ||
           !args.empty?
         self.prototype(method, *args, &block)
+      # TODO: Remove (2026-04-28)
+      # Experiment with supporting only property setting for those
+      # declared in StoryTeller::Library.declarations.properties.
+      # elsif (properties.respond_to?(:key?) && properties.key?(property)) ||
+      #     (respond_to?(:_key?) && _key?(property)) ||
+      #     StoryTeller::Library.declarations.properties.key?(property)
+      #   self.prototype(method, *args, &block)
       else
         super
       end
@@ -172,6 +179,7 @@ module Inform
     # rubocop: enable Metrics/PerceivedComplexity
     # rubocop: enable Style/MissingRespondToMissing
 
+    # TODO: Remove (2026-04-28)
     # def respond_to_missing?(method, include_all=false)
     #   m = method.to_s
     #   return false if m =~ /\?$/

data/lib/story_teller/stdlib.rb

@@ -19,6 +19,8 @@
 # You should have received a copy of the GNU General Public License
 # along with StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
 
+require_relative 'version'
+
 # The Inform module
 module Inform
 # These are built-ins primarily found used in the InformLibrary.
@@ -430,7 +432,7 @@ module StdLib
     # appropriate.
     nil # false
   rescue StandardError => e
-    log.error "Error getting reaction from #{obj}", e
+    log.error "Error getting reaction from #{obj.identity}", e
     e.backtrace.each { |t| log.error t }
   ensure
     obj.inflib = si

data/lib/story_teller/version.rb

@@ -23,7 +23,7 @@
 module StoryTeller
   # module Engine
   module Engine
-    VERSION = '1.2.1'.freeze
+    VERSION = '1.2.3'.freeze
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: inform-runtime
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Nels Nelson
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +124,7 @@ files:
 - lib/story_teller/mixins.rb
 - lib/story_teller/model_adapter.rb
 - lib/story_teller/plurals.rb
+- lib/story_teller/privileges.rb
 - lib/story_teller/prototype.rb
 - lib/story_teller/publication.rb
 - lib/story_teller/session.rb