inform-runtime 1.0.4

data/lib/runtime/helpers.rb

@@ -0,0 +1,177 @@
+# 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/>.
+
+# Additional mixin methods
+
+# The Inform module
+module Inform
+  # Some mixins provide exclusive Inform-ification for Ruby, withheld
+  # from mixins.rb because of said exclusivity
+  module SetHelpers
+    def in?(*others)
+      return false unless others.respond_to?(:include?)
+      others.flatten.include?(self)
+    end
+
+    def notin?(*others)
+      return false unless others.respond_to?(:include?)
+      !others.flatten.include?(self)
+    end
+  end
+
+  # Stub helpers for NilClass instances
+  module NilClassSetHelpers
+    def in?(*)
+      false
+    end
+  end
+end
+
+# The Inform module
+module Inform
+  # String helper methods mostly for use by Inform::ParseNoun
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # rubocop: disable Metrics/MethodLength
+  # rubocop: disable Metrics/PerceivedComplexity
+  module Matchers
+    def matches?(obj, regexp = /^#{self}/i, delimeter = /[,\s]+/, str = self)
+      return false if str.nil? || (str.respond_to?(:empty?) && str.empty?)
+      return false unless obj.object?
+      k = obj.name
+      k = k.split(delimeter) if k.respond_to?(:split)
+      return str if k.respond_to?(:grep) && !k.grep(regexp).empty?
+      return str if k.respond_to?(:match?) && k.match?(regexp)
+      false
+    rescue StandardError => e
+      log.error e
+      false
+    end
+
+    def matches_exactly?(obj, regexp = /^#{self}$/i, delimeter = /[,\s]+/, str = self)
+      return false if str.nil? || (str.respond_to?(:empty?) && str.empty?)
+      return false unless obj.object?
+      k = obj.name
+      return str if k.respond_to?(:match?) && k.match?(regexp)
+      k = k.split(delimeter) if k.respond_to?(:split)
+      return str if k.respond_to?(:grep) && !k.grep(regexp).empty?
+      return str if k.respond_to?(:match?) && k.match?(regexp)
+      false
+    rescue StandardError => e
+      log.error e
+      false
+    end
+
+    def matches_any_exactly?(obj, regexp = /^#{self}$/i, delimeter = /[,\s]+/, str = self)
+      return false if str.nil? || (str.respond_to?(:empty?) && str.empty?)
+      return false unless obj.object?
+      k = obj.name
+      k = k.split(delimeter) if k.respond_to?(:split)
+      return str if k.respond_to?(:grep) && !k.grep(regexp).empty?
+      false
+    rescue StandardError => e
+      log.error e
+      false
+    end
+
+    def matches_last_exactly?(obj, regexp = /^#{self}$/i, delimeter = /[,\s]+/, str = self)
+      return false if str.nil? || (str.respond_to?(:empty?) && str.empty?)
+      return false unless obj.object?
+      k = obj.name
+      k = k.split(delimeter) if k.respond_to?(:split)
+      k = k.last if k.respond_to?(:last)
+      return str if k.respond_to?(:match?) && k.match?(regexp)
+      false
+    rescue StandardError => e
+      log.error e
+      false
+    end
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/CyclomaticComplexity
+  # rubocop: enable Metrics/MethodLength
+  # rubocop: enable Metrics/PerceivedComplexity
+  # module Matchers
+end
+# module Inform
+
+# The Object class to add some Inform helper methods
+class Object
+  include Inform::SetHelpers
+  include Inform::Matchers
+
+  alias exhibits? kind_of?
+end
+
+# The NilClass class to add some Inform helper methods
+class NilClass
+  include Inform::NilClassSetHelpers
+end
+
+# The Enumerable module to add some Inform helper methods
+module Enumerable
+  include Inform::SetHelpers
+
+  def inform(o = '')
+    each { |x| x.inform(o) if x.respond_to?(: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::System::Object)
+    end
+
+    def sysobj?(obj = self)
+      obj.is_a?(Inform::System::Object)
+    end
+  end
+end
+
+# The Inform module
+module Inform
+  # The NilClassObjectHelpers module functionality
+  module NilClassObjectHelpers
+    def object?
+      false
+    end
+
+    def sysobj?
+      false
+    end
+
+    def list_together
+      self
+    end
+  end
+end
+
+# Define some built-in Inform helper methods
+class Object
+  include Inform::ObjectHelpers
+end
+
+# Define some built-in Inform helper methods
+class NilClass
+  include Inform::NilClassObjectHelpers
+end

data/lib/runtime/history.rb

@@ -0,0 +1,45 @@
+# 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 History module
+  module History
+    DefaultHistoryLimit = 10
+    Histories = defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : {}
+    HistoryCommandPattern = %r{^(!|history)$}.freeze
+
+    def history
+      Histories[@player.identity] ||= []
+    end
+
+    def history_limit
+      return DefaultHistoryLimit unless @player.respond_to?(:preferences)
+      @player.preferences.|(:history_limit, DefaultHistoryLimit).to_i
+    end
+
+    def record_history(s)
+      return if s.nil? || s.empty? || HistoryCommandPattern.match?(s)
+      history.delete_if { |i| i == s }
+      history.push(s)
+      history.shift if history.length > history_limit
+    end
+  end
+end

data/lib/runtime/inflector.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright (c) 2004-2014 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# == License
+
+# Active Support is released under the MIT license:
+
+# * http://www.opensource.org/licenses/MIT
+
+# The Inform module
+module Inform
+  # The Inflector module
+  module Inflector
+    extend self # rubocop: disable Style/ModuleFunction
+
+    # The Inflections class
+    class Inflections
+      @instance = nil
+
+      def self.instance
+        @instance ||= new
+      end
+
+      attr_reader :plurals, :singulars, :uncountables, :propers
+
+      def initialize
+        clear_fields
+      end
+
+      def clear_fields(fields = %i[plurals singulars uncountables propers])
+        fields.each { |field| instance_variable_set(:"@#{field}", []) }
+      end
+
+      def plural(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @plurals.prepend([rule, replacement])
+      end
+
+      def singular(rule, replacement)
+        @uncountables.delete(rule) if rule.is_a?(String)
+        @uncountables.delete(replacement)
+        @singulars.prepend([rule, replacement])
+      end
+
+      def defective(noun)
+        @plurals.unshift([/^#{noun}$/i, noun])
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/MethodLength
+      def irregular(singular, plural)
+        @uncountables.delete(singular)
+        @uncountables.delete(plural)
+
+        s0 = singular[0]
+        srest = singular[1..]
+
+        p0 = plural[0]
+        prest = plural[1..]
+
+        if s0.upcase == p0.upcase
+          plural(/(#{s0})#{srest}$/i, '\1' + prest)
+          plural(/(#{p0})#{prest}$/i, '\1' + prest)
+
+          singular(/(#{s0})#{srest}$/i, '\1' + srest)
+          singular(/(#{p0})#{prest}$/i, '\1' + srest)
+        else
+          plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+          plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+          plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+          plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+
+          singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+          singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+          singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+          singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+        end
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/MethodLength
+
+      def uncountable(*words)
+        (@uncountables << words).flatten!
+      end
+
+      def proper(rule, replacement)
+        @propers.unshift([rule, replacement])
+      end
+
+      def clear(scope = :all)
+        case scope
+        when :all
+          clear_fields
+        else
+          clear_fields([scope])
+        end
+      end
+    end
+    # class Inflections
+
+    def inflections
+      return yield Inflections.instance if block_given?
+      Inflections.instance
+    end
+  end
+  # module Inflector
+
+  # rubocop: disable Metrics/BlockLength
+  Inflector.inflections do |inflect|
+    inflect.plural(/$/, 's')
+    inflect.plural(/s$/i, 's')
+    inflect.plural(/^(ax|test)is$/i, '\1es')
+    inflect.plural(/(octop|vir)us$/i, '\1i')
+    inflect.plural(/(octop|vir)i$/i, '\1i')
+    inflect.plural(/(alias|status)$/i, '\1es')
+    inflect.plural(/(bu)s$/i, '\1ses')
+    inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+    inflect.plural(/([ti])um$/i, '\1a')
+    inflect.plural(/([ti])a$/i, '\1a')
+    inflect.plural(/sis$/i, 'ses')
+    inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    inflect.plural(/(hive)$/i, '\1s')
+    inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+    inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    inflect.plural(/^(m|l)ouse$/i, '\1ice')
+    inflect.plural(/^(m|l)ice$/i, '\1ice')
+    inflect.plural(/^(ox)$/i, '\1en')
+    inflect.plural(/^(oxen)$/i, '\1')
+    inflect.plural(/(quiz)$/i, '\1zes')
+
+    inflect.singular(/s$/i, '')
+    inflect.singular(/(ss)$/i, '\1')
+    inflect.singular(/(n)ews$/i, '\1ews')
+    inflect.singular(/([ti])a$/i, '\1um')
+    inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+    inflect.singular(/(^analy)(sis|ses)$/i, '\1sis')
+    inflect.singular(/([^f])ves$/i, '\1fe')
+    inflect.singular(/(hive)s$/i, '\1')
+    inflect.singular(/(tive)s$/i, '\1')
+    inflect.singular(/([lr])ves$/i, '\1f')
+    inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    inflect.singular(/(s)eries$/i, '\1eries')
+    inflect.singular(/(m)ovies$/i, '\1ovie')
+    inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+    inflect.singular(/^(m|l)ice$/i, '\1ouse')
+    inflect.singular(/(bus)(es)?$/i, '\1')
+    inflect.singular(/(o)es$/i, '\1')
+    inflect.singular(/(shoe)s$/i, '\1')
+    inflect.singular(/(cris|test)(is|es)$/i, '\1is')
+    inflect.singular(/^(a)x[ie]s$/i, '\1xis')
+    inflect.singular(/(octop|vir)(us|i)$/i, '\1us')
+    inflect.singular(/(alias|status)(es)?$/i, '\1')
+    inflect.singular(/^(ox)en/i, '\1')
+    inflect.singular(/(vert|ind)ices$/i, '\1ex')
+    inflect.singular(/(matr)ices$/i, '\1ix')
+    inflect.singular(/(quiz)zes$/i, '\1')
+    inflect.singular(/(database)s$/i, '\1')
+
+    inflect.irregular('child', 'children')
+    inflect.irregular('man', 'men')
+    inflect.irregular('move', 'moves')
+    inflect.irregular('glove', 'gloves')
+    inflect.irregular('person', 'people')
+    inflect.irregular('sex', 'sexes')
+    inflect.irregular('zombie', 'zombies')
+
+    inflect.uncountable(%w[equipment information rice money species series fish sheep jeans police])
+  end
+  # rubocop: enable Metrics/BlockLength
+  # Inflector.inflections do |inflect|
+end
+# module Inform

data/lib/runtime/io.rb

@@ -0,0 +1,174 @@
+# 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 IO module
+  module IO
+    def session
+      return unless defined?(Inform::IO::Session) && Inform::IO::Session.respond_to?(:of)
+      @session ||= Inform::IO::Session.of(self)
+    end
+
+    def noop; end
+
+    def connections
+      subscribed_connections = explicit_subscribers.select { |a| a.is_a? Connection }
+      if respond_to?(:inflib) && !inflib.nil? && subscribed_connections.empty?
+        subscribed_connections = inflib.explicit_subscribers.select { |a| a.is_a? Connection }
+      end
+      subscribed_connections
+    end
+
+    def read
+      $stdin.gets(chomp: true)
+    end
+
+    def out(s)
+      if defined?(Curses)
+        Curses.addstr s
+      else
+        $stdout.write(s)
+      end
+    end
+
+    def inform(s = '')
+      s = invert_illeism(self, s) if respond_to?(:invert_illeism)
+      new_line
+      println s
+      new_line if s.is_a?(Array) && !s.empty?
+      prompt
+      flush_io
+      true
+    end
+    alias update inform
+
+    def flush_io
+      $stdout.flush
+    end
+
+    def tidy_output(s, columns = 76)
+      s.gsub!(/^\n+/, "\n")
+      return s if s.length < columns || columns == 0
+      s.gsub(/(.{#{columns}}\S+)( +|$\n?)/, "\\1\n")
+    end
+
+    def new_line
+      out "\n"
+    end
+
+    def spaces(n)
+      out(' ' * n)
+    end
+
+    def print(s = '')
+      out(s.to_s)
+    end
+
+    def println(s = '', isolate: false)
+      _isolated = (isolate == true) # TODO: Implement
+      return print(s) if s.is_a?(Array)
+      out(s.to_s + "\n")
+    end
+
+    def output_stream(i, s); end
+
+    def reset_prompt
+      @prompt = nil
+    end
+
+    def prompt(s = @prompt)
+      out(@prompt = s || "\n>")
+    end
+
+  # ----------------------------------------------------------------------------
+  #   Adapted from the C code for ls.  :-)
+  # ----------------------------------------------------------------------------
+
+    ItemPaddingString = '%<item>s%<padding>s'.freeze
+    MinimumLineLength = 30
+    MinimumCellPadding = 8
+    MinimumColumnPadding = 2
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def many_per_line(items)
+      max = 0
+
+      lines = []
+      prefs = @player.linkto :preferences
+      line_length = prefs ? prefs.word_wrap.to_i : MinimumLineLength
+      line_length = MinimumLineLength if line_length <= MinimumLineLength
+      buffer = ''
+
+      items.each do |item|
+        max = [item.length, max].max
+      end
+      max += MinimumColumnPadding
+      width = (line_length - MinimumCellPadding) / max
+      height = (items.length / width).ceil - 1
+
+      return if width == 0
+
+      columns = []
+      i = 0
+      loop do
+        # Build a list of columns with nil padding
+        column = items[i, height]
+        columns << column + Array.new(height - column.length)
+        i += height
+        break if (i + height) >= (items.length + height)
+      end
+
+      m = []
+      loop do
+        m << []
+        for column in columns
+          m.last << column.shift
+        end
+        break if columns.last.empty?
+      end
+
+      m.each do |row|
+        buffer = "\e[51m"
+        row.each do |item|
+          next unless item
+          n = [max - item.length, MinimumColumnPadding].max
+          padding = " " * n unless item == row.last
+          buffer += format(ItemPaddingString, item: item, padding: padding)
+        end
+        buffer += "\e[56m"
+        lines << buffer.strip
+        buffer = ''
+      end
+
+      lines
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+    # def many_per_line
+  end
+  # module IO
+end
+# module Inform