inform-runtime 1.0.4

data/lib/runtime/articles.rb

@@ -0,0 +1,138 @@
+# 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 Articles module
+  # Support standard Inform methods for dynamically applying appropriate
+  # articles to nouns.
+  module Articles
+    LowercaseTheSpaceString = 'the '.freeze
+    LowercaseSomeSpaceString = 'some '.freeze
+
+    # TODO: Add support for on-the-fly indefinite/definite mode
+    # differentiation based on the inclusion of the noun (x1) in
+    # the pronouns table.
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    def the(obj)
+      return Inform::English::NOTHING__TX if obj.nil?
+      return PrefaceByArticle(obj, 0) if obj.is_a?(String)
+      return obj.to_s unless obj.respond_to?(:has?)
+      return obj.to_s if obj.has?(:proper)
+      return obj.article + ' ' + obj.to_s if obj.string?(:article)
+      return your(obj) if obj.respond_to?(:owner) && obj.owner == player
+      # PrefaceByArticle(obj, 1)
+      LowercaseTheSpaceString + obj.to_s
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+
+    def The(obj)
+      return obj.to_s unless obj.respond_to?(:has?)
+      return obj.to_s if obj.has?(:proper)
+      the(obj).capitalize
+    end
+
+    def defart(obj)
+      return theirself(obj) if obj == player
+      return hisorher(player, obj) if player.descendants.include?(obj)
+      the(obj)
+    end
+
+    def indefart(obj)
+      return theirself(obj) if obj == player
+      return hisorher(player, obj) if player.descendants.include?(obj)
+      a(obj)
+    end
+
+    LowercaseASpaceString = 'a '.freeze
+
+    # rubocop: disable Metrics/AbcSize
+    def a(obj)
+      return Inform::English::NOTHING__TX if obj.nil?
+      return PrefaceByArticle(obj, 1) if obj.is_a?(String)
+      return obj.to_s unless obj.respond_to?(:has?)
+      return obj.to_s if obj.has?(:proper)
+      return obj.article + ' ' + obj.to_s if obj.string?(:article)
+      return LowercaseSomeSpaceString + obj.to_s if obj.has?(:pluralname)
+      # PrefaceByArticle(obj, 1)
+      LowercaseASpaceString + obj.to_s
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    def A(obj)
+      a(obj)&.sentence_case || obj.to_s
+    end
+
+    def isorare(obj); IsorAre(obj); end
+
+    def itorthem(obj);       ItorThem(obj);       end
+
+    def thatorthose(obj);    ThatorThose(obj);    end
+
+    def Cthatorthose(obj);   CThatorThose(obj);   end
+
+    def cthatorthose(obj);   CThatorThose(obj);   end
+
+    def Ctheyreorthats(obj); CTheyreorThats(obj); end
+
+    def ctheyreorthats(obj); CTheyreorThats(obj); end
+  end
+  # module Articles
+
+  # Re-open the Inform::Parser module
+  module Parser
+    include Inform::Articles
+
+    VowelsOrHiPattern = %r{^([aeiou]|hi).+}.freeze
+
+    # TODO: Figure out why this isn't being called by #a(obj) above.
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def PrefaceByArticle(o, _acode, pluralise = false, capitalise = false)
+      log.info "wtf1 #{self.class}##{__method__}" # TODO: Remove
+      if (obj_articles = o.&:articles) && obj_articles.respond_to?(:[])
+        return obj_articles[acode] unless obj_articles[acode].nil?
+        return if pluralise
+      end
+      return if pluralise
+      if VowelsOrHiPattern.match?(o.to_s)
+        return "an #{o}".sentence_case if capitalise
+        "an #{o}"
+      else
+        return "a #{o}".sentence_case if capitalise
+        "a #{o}"
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+  end
+  # module Parser
+
+  module Verbs
+    include Inform::Articles
+  end
+end
+# module Inform

data/lib/runtime/builtins.rb

@@ -0,0 +1,359 @@
+# 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 'set'
+
+require 'method_source' # Require the method_source gem
+
+require_relative 'articles'
+require_relative 'color'
+require_relative 'plurals'
+
+# These are built-ins which may be used throughout the Inform namespace.
+# TODO: Consider moving these into a module included in the Kernel module.
+module Inform
+  include Inform::Articles
+  include Inform::Color
+  include Inform::Plurals
+
+  alias random rand
+
+  def dictionary
+    Inform::Dictionary
+  end
+
+  def compass
+    InformLibrary::Compass
+  end
+
+  def nothing
+    nil
+  end
+
+  def content; respond_to?(:descendants) ? self.descendants : Array::Empty; end
+  alias contents content
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/MethodLength
+  # rubocop: disable Metrics/PerceivedComplexity
+  def with(context = nil, &block)
+    return self if block.nil?
+    existing_methods = self.singleton_methods(false)
+
+    if context.nil?
+      self.instance_eval(&block)
+    else
+      self.instance_exec(context, &block)
+    end
+
+    # Only persist methods being defined just now on *this* instance
+    added = self.singleton_methods(false) - existing_methods
+    added.select! do |m|
+      self.singleton_class.instance_method(m).owner == self.singleton_class
+    end
+
+    if added.any?
+      persisted = self.properties.fetch(:instance_behavior, '')
+      added.each do |method_name|
+        source = method_source(method_name)
+        next if source.nil?
+        # Only support def ... end blocks
+        next unless resembles_method?(source)
+        persisted << source unless persisted.include?(source)
+      end
+      unless persisted.empty?
+        self.will_change_column(:properties) if self.respond_to?(:will_change_column)
+        self.properties[:instance_behavior] = persisted
+      end
+    end
+    self.save_changes if self.respond_to?(:save_changes)
+    self
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/MethodLength
+  # rubocop: enable Metrics/PerceivedComplexity
+
+  MethodDefinitionPattern = /\s*def\s+/.freeze
+  MethodTerminationPattern = /\s*end$/.freeze
+
+  def resembles_method?(source)
+    MethodDefinitionPattern.match?(source) && MethodTerminationPattern.match?(source)
+  end
+
+  def method_source(method_name)
+    self.singleton_class.instance_method(method_name).source
+  rescue StandardError => _e
+    nil
+  end
+
+  def apply_instance_behavior!
+    source = self.properties[:instance_behavior]
+    return if source.nil? || source.empty?
+    return unless source.include?('def ')
+    self.instance_eval(source, "(instance_behavior for #{self.identity})", 1)
+  rescue NameError => e
+    log.warn "[InstanceBehavior] #{e.class}: #{e.message}"
+  end
+
+  def workflags
+    Thread.current[:workflags] ||= Set.new
+  end
+
+  def initial
+    # TODO: What is this supposed to return?
+  end
+
+  def ofclass(klass)
+    self.is_a?(klass)
+  end
+  alias ofclass? ofclass
+
+  def provides?(prop)
+    symbolized_prop = prop.to_sym
+    return symbolized_prop if self.respond_to?(symbolized_prop)
+    downcased_prop = symbolized_prop.downcase
+    return downcased_prop if self.respond_to?(downcased_prop)
+    false
+  end
+
+  def react_after?(action_routine = action)
+    return false if action_routine.nil?
+    self.apply_modules if self.respond_to?(:apply_modules)
+    self.provides?('react_after_' + action_routine)
+  rescue StandardError => e
+    log.error "Error checking for after reaction: #{e.message}", e
+    false
+  end
+
+  def react_before?(action_routine = action)
+    return false if action_routine.nil?
+    self.apply_modules if self.respond_to?(:apply_modules)
+    self.provides?('react_before_' + action_routine)
+  rescue StandardError => e
+    log.error "Error checking for before reaction: #{e.message}", e
+    false
+  end
+
+  def life?(action_routine = action)
+    return false if action_routine.nil?
+    self.apply_modules if self.respond_to?(:apply_modules)
+    self.provides?('life_' + action_routine)
+  rescue StandardError => e
+    log.error "Error checking for life reaction: #{e.message}", e
+    false
+  end
+
+  def objectloop(*_args, &block)
+    if self.is_a?(InformLibrary)
+      Inform::Object.all.each { |o| block.call(o) }
+    elsif self.respond_to?(:descendants)
+      self.descendants.each { |o| block.call(o) }
+    end
+  end
+
+  def getobject(id)
+    o = Inform::Object[id]
+    o.refresh
+  rescue StandardError
+    raise NoSuchObject
+  end
+
+  def findobject(*args, &block)
+    return Inform::Object.dataset.order(:name, :id).grep(:name, *args).to_a if args.first.is_a?(Regexp)
+    Inform::Object.dataset.grep(&block).to_a
+  end
+
+  def deadflag; @deadflag; end
+
+  def deadflag=(flag); @deadflag = flag; end
+
+  def the_time; @the_time.nil? ? 0 : @the_time; end
+
+  def the_time=(the_time); @the_time = the_time; end
+
+  def score; @score.nil? ? 0 : @score; end
+
+  def score=(score); @score = score; end
+
+  def things_score; @things_score.nil? ? 0 : @things_score; end
+
+  def things_score=(things_score); @things_score = things_score; end
+
+  def visibility_ceiling=(visibility_ceiling)
+    e = Thread.current[:event]
+    @visibility_ceiling = visibility_ceiling
+    e.visibility_ceiling = visibility_ceiling if e
+  end
+
+  def topic
+    consult_words
+  end
+  alias text topic
+
+  def number(x = nil)
+    return special_number1 if x.nil?
+    LanguageNumber(x)
+    ''
+  end
+
+  def special
+    @special_word
+  end
+
+  def num_words
+    @words.nil? || @words.empty? ? 0 : @words.length
+  end
+
+  def current_word
+    @words[@wn] || ''
+  end
+
+  def remaining_words
+    @words[@wn..]
+  end
+
+  def language_pronouns
+    # TODO: Cleanup upon disconnect
+    key = self.respond_to?(:inflib) ? self.inflib : self.identity
+    LanguagePronouns[key] ||= Marshal.load(Marshal.dump(LanguagePronouns[:default]))
+  end
+
+  def language_descriptors
+    # TODO: Cleanup upon disconnect
+    key = self.respond_to?(:inflib) ? self.inflib : self.identity
+    LanguageDescriptors[key] ||= Marshal.load(Marshal.dump(LanguageDescriptors[:default]))
+  end
+
+  def light_adjusted(obj = @player)
+    # TODO: Consider performing the following in another thread or an event
+    obj.root.descendants.each do |o|
+      o.inflib.send(:AdjustLight, true) if o.has?(:creature) && !o.inflib.nil?
+    end
+  end
+
+  def go(obj)
+    invoke :Go, obj
+  end
+
+  def say(*s)
+    invoke :Say, s.flatten.sample
+  end
+
+  def emote(*s)
+    return consult_words if s.empty?
+    invoke :Emote, s.flatten.sample
+  end
+
+  def drop(obj)
+    invoke :Drop, obj
+  end
+
+  def search(obj)
+    invoke :Search, obj
+  end
+
+  def disrobe(obj)
+    invoke :Disrobe, obj
+  end
+
+  def quit
+    Inform::Runtime.instance.quit
+    publish :disconnect
+  end
+
+  # ----------------------------------------------------------------------------
+  #  (From the Inform Designer's Manual)
+  #  §26 Describing objects and rooms
+  # ----------------------------------------------------------------------------
+  # To print the name of such an object, Inform does the following:
+  #
+  #   (1) If the short_name is a string, it's printed and that's all.
+  #   (2) If it is a routine, then it is called. If it returns true, that's all.
+  #   (3) The text given in the header of the object definition is printed.
+  # ----------------------------------------------------------------------------
+  def to_s
+    textual_name = self.short_name if self.respond_to?(:short_name)
+    return textual_name if textual_name.is_a?(String)  # (1)
+    return if textual_name == true                     # (2)
+    if self.respond_to?(:name)
+      return self.name.join(' ') if self.name.respond_to?(:join)
+      return self.name.to_s                            # (3)
+    end
+    self.identity
+  end
+  alias to_str to_s
+
+  def classification
+    type = object_type.to_s
+    clazz = self.class.to_s
+    return type if type == clazz
+    "#{type} < #{clazz}"
+  end
+
+  def randomly(n = 3)
+    rand * n
+  end
+
+  def pause(n)
+    sleep(n)
+    :inform
+  end
+
+  def library_method?(method)
+    Inform::Library.methods_index.include?(method) && respond_to?(method)
+  end
+
+  VERB        = 1
+  PLURAL      = 4
+  PREPOSITION = 8
+  NOUN        = 128
+  def dict_par1(w, par = 0)
+    # +128 if given a noun, +8 if a preposition, +4 if plural, +1 if a verb
+    par += NOUN if Inform::Dictionary.include?(w.to_sym)
+    par += PREPOSITION if Inform::English::Prepositions.include?(w)
+    par += PLURAL if plural?(w)
+    par += VERB unless Inform::Grammar::Verbs.lookup(w).nil?
+    par
+  end
+
+  protected
+
+  CommaSpacePattern = %r{[,\s]+}.freeze
+  NonAlphabeticPattern = %r{[^a-z]}i.freeze
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/PerceivedComplexity
+  def index_words(obj = self)
+    return unless obj.respond_to?(:name)
+    k = obj.name
+    return if k.nil? || (k.respond_to?(:empty?) && k.empty?)
+    a = k.split(CommaSpacePattern).grep_v(NonAlphabeticPattern) if k.respond_to?(:split)
+    return unless k.respond_to?(:gsub!)
+    a = k.gsub!(NonAlphabeticPattern, '') if a.nil? || a.empty?
+    Inform::Dictionary.merge(a.map(&:downcase).map(&:intern))
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/PerceivedComplexity
+end
+# module Inform

data/lib/runtime/color.rb

@@ -0,0 +1,145 @@
+# 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 Color module
+  module Color
+    StyleCodes = {
+      plain: [
+        "\e[0m", "\e[0m"],
+      bold: [
+        "\e[1m", "\e[22m"],
+      italic: [
+        "\e[3m", "\e[23m"],
+      underline: [
+        "\e[4m", "\e[24m"],
+      blink: [
+        "\e[5m", "\e[25m"],
+      flash: [
+        "\e[6m", "\e[26m"],
+      inverse: [
+        "\e[7m", "\e[27m"],
+      hidden: [
+        "\e[8m", "\e[28m"],
+      strikethrough: [
+        "\e[9m", "\e[29m"]
+    }.freeze
+
+    ColorCodes = {
+      default: [
+        "\e[0m", "\e[0m"],
+      black: [
+        "\e[30m", "\e[39m"],
+      black_on_white: [
+        "\e[30m", "\e[39m"],
+      red: [
+        "\e[31m", "\e[39m"],
+      green: [
+        "\e[32m", "\e[39m"],
+      yellow: [
+        "\e[33m", "\e[39m"],
+      blue: [
+        "\e[34m", "\e[39m"],
+      purple: [
+        "\e[35m", "\e[39m"],
+      magenta: [
+        "\e[35m", "\e[39m"],
+      cyan: [
+        "\e[36m", "\e[39m"],
+      white: [
+        "\e[37m", "\e[39m"]
+    }.freeze
+
+    BackgroundColorCodes = {
+      default: [
+        "\e[0m", "\e[0m"],
+      black: [
+        "\e[40m", "\e[49m"],
+      red: [
+        "\e[41m", "\e[49m"],
+      green: [
+        "\e[42m", "\e[49m"],
+      yellow: [
+        "\e[43m", "\e[49m"],
+      blue: [
+        "\e[44m", "\e[49m"],
+      purple: [
+        "\e[45m", "\e[49m"],
+      magenta: [
+        "\e[45m", "\e[49m"],
+      cyan: [
+        "\e[46m", "\e[49m"],
+      white: [
+        "\e[47m", "\e[49m"]
+    }.freeze
+
+    # Text style and color for terminals
+    def style(style, text = nil)
+      code = (StyleCodes[style] || StyleCodes[:plain]).first
+      return code + text + (StyleCodes[style] || StyleCodes[:plain]).last unless text.nil?
+      print code
+    end
+    def un_style(style)
+      print((StyleCodes[style] || StyleCodes[:plain]).last)
+    end
+    alias unstyle un_style
+    def color(color, text = nil)
+      code = (ColorCodes[color] || ColorCodes[:default]).first
+      return code + text + (ColorCodes[color] || ColorCodes[:default]).last unless text.nil?
+      print code
+    end
+    def un_color(color)
+      print((ColorCodes[color] || ColorCodes[:default]).last)
+    end
+    alias uncolor un_color
+    def background_color(color, text = nil)
+      code = (BackgroundColorCodes[color] || BackgroundColorCodes[:default]).first
+      return code + text + (BackgroundColorCodes[color] || BackgroundColorCodes[:default]).last unless text.nil?
+      print code
+    end
+    alias bgcolor background_color
+    def un_background_color(color)
+      print((BackgroundColorCodes[color] || BackgroundColorCodes[:default]).last)
+    end
+    alias unbgcolor un_background_color
+
+    NearestColor = {
+      red: %i[
+        crimson brick salmon coral],
+      yellow: %i[
+        golden orange],
+      green: %i[
+        seagreen teal forestgreen],
+      blue: %i[
+        aqua cyan skyblue turqoise],
+      magenta: %i[
+        lavender fuchsia indigo orchid plum purple violet]
+    }.freeze
+
+    def nearest_color(color)
+      colors = NearestColor.select { |_, v| v.include?(color) }
+      return colors.first.first unless colors.empty?
+      :white
+    end
+  end
+  # module Color
+end
+# module Inform