inform-runtime 1.0.4

data/lib/runtime/options.rb

@@ -0,0 +1,104 @@
+# 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 'logger'
+require 'optparse'
+
+require_relative 'version'
+
+# The Inform module
+module Inform
+  # The Options module
+  module Options
+    # The ArgumentsParser
+    class ArgumentsParser
+      attr_reader :parser, :options
+
+      def initialize(args, option_parser = OptionParser.new, **params)
+        @parser = option_parser
+        @options = ::Inform::Runtime.default_config.dup
+        flags.each { |method_name| self.method(method_name).call }
+        @parser.parse!(args, **params)
+      end
+
+      def flags
+        @flags ||= %i[banner admin log_level help version]
+      end
+
+      def banner
+        @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [game_path] [options]"
+        @parser.separator ''
+        @parser.separator 'Arguments:'
+        @parser.separator '    game_path                        Path to game file or directory'
+        @parser.separator ''
+        @parser.separator 'Options:'
+      end
+
+      def admin
+        @parser.on_tail('--admin', 'Set player character as admin; default: false') do
+          @options[:admin] = true
+        end
+      end
+
+      def log_level
+        @parser.on_tail('-v', '--verbose', 'Increase verbosity') do
+          @options[:log_level] ||= Logger::INFO
+          @options[:log_level] -= 1
+        end
+      end
+
+      def help
+        @parser.on_tail('-?', '--help', 'Show this message') do
+          puts @parser
+          exit
+        end
+      end
+
+      def version
+        @parser.on_tail('--version', 'Show version') do
+          puts "#{$PROGRAM_NAME} version #{Inform::VERSION}"
+          exit
+        end
+      end
+    end
+    # class ArgumentsParser
+
+    def demand(options, arg, positional = false)
+      return options[arg] unless options[arg].nil?
+      required_arg = positional ? "<#{arg}>" : "--#{arg.to_s.gsub(/_/, '-')}"
+      raise UserError, "Required argument: #{required_arg}"
+    end
+
+    def parse_arguments(args = ARGV, _file_path = ARGF)
+      arguments_parser = ArgumentsParser.new(args)
+      demand(arguments_parser.options, :game_path)
+      arguments_parser.options
+    rescue OptionParser::InvalidArgument, OptionParser::InvalidOption,
+           OptionParser::MissingArgument, OptionParser::NeedlessArgument => e
+      puts e.message
+      puts arguments_parser.parser
+      exit
+    rescue OptionParser::AmbiguousOption => e
+      abort e.message
+    end
+  end
+  # module Options
+end
+# module Inform

data/lib/runtime/persistence.rb

@@ -0,0 +1,292 @@
+# 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 'etc'
+require 'logger'
+require 'uri'
+require 'yaml'
+
+require 'sequel'
+
+require_relative 'database'
+
+Sequel.extension :migration
+Sequel.extension :connection_validator
+
+# Re-open the Inform module to define a helper method
+module Inform
+  def self.initialize_persistence_layer
+    log.debug "Inform.initialize_persistence_layer"
+    Inform::Persistence.init
+  end
+end
+
+# Simplistic in-memory cache
+class EphemeralCache < Hash
+  def get(key)
+    self[key]
+  end
+  def set(key, value, _ttl)
+    self[key] = value
+  end
+end
+
+# The Persistence class
+class Persistence
+  unless defined?(Persistence::GlobalCache)
+    GlobalCache = defined?(Java) ? java.util.concurrent.ConcurrentHashMap.new : EphemeralCache.new
+  end
+  Plugins = {
+    after_initialize: [],
+    caching: [Persistence::GlobalCache],
+    json_serializer: [],
+    xml_serializer: []
+  #   tactical_eager_loading: [],
+  #   eager_each: []
+  }.freeze
+end
+
+# The SequelLoggers module
+module SequelLoggers
+  DatabaseLogging = Struct.new(:memo).new({})
+
+  def add_logger(database, logger)
+    database.loggers << logger unless database.loggers.include?(logger)
+  end
+
+  def delete_logger(database, logger)
+    database.loggers.delete(logger) if database.loggers.include?(logger)
+  end
+
+  def set_log_level(database, level)
+    DatabaseLogging.memo[:preserved_log_levels][database] = database.sql_log_level
+    database.sql_log_level = level unless level.nil?
+  end
+
+  def enable_query_logging
+    DatabaseLogging.memo[:logger] ||= Logger.new($stdout)
+    DatabaseLogging.memo[:preserved_log_levels] ||= {}
+    logger = DatabaseLogging.memo[:logger]
+    Sequel::DATABASES.each do |database|
+      add_logger(database, logger)
+      set_log_level(database, :debug)
+      logger.debug "Enabled query logging for #{database}"
+    end
+  end
+
+  def disable_query_logging
+    logger = DatabaseLogging.memo[:logger]
+    Sequel::DATABASES.each do |database|
+      logger.debug "Disabling query logging for #{database}"
+      delete_logger(database, logger)
+      set_log_level(database, DatabaseLogging.memo[:preserved_log_levels][database])
+    end
+  end
+end
+# module SequelLoggers
+
+# The SequelPlugins module
+module SequelPlugins
+  def enable_plugins
+    Persistence::Plugins.each { |plugin, parameters| enable_plugin(plugin, parameters) }
+  end
+
+  def enable_plugin(plugin, parameters = [])
+    return Sequel::Model.plugin(plugin) if parameters.empty?
+    Sequel::Model.plugin(plugin, *parameters)
+  rescue LoadError => e
+    log.error e.message
+  end
+end
+# module SequelPlugins
+
+# The Inform module
+module Inform
+  # The Persistence class
+  class Persistence
+    include DatabaseConnectionHelpers
+    include SequelLoggers
+    include SequelPlugins
+
+    attr_reader :config, :environment
+
+    def self.init(env = nil)
+      Inform::Persistence.instance(env)
+    end
+
+    @instance_mutex = Mutex.new
+
+    def self.instance(*args)
+      return @instance unless @instance.nil?
+      @instance_mutex.synchronize do
+        @instance ||= new(*args)
+      end
+      @instance
+    end
+
+    private_class_method :new
+
+    def initialize(env = nil)
+      @environment = env || Inform::Game.environment
+      log.debug "Initializing persistence layer for environment: #{@environment}"
+      caller[0..4].each { |t| log.debug t }
+      @config = database_config.fetch(@environment.to_s, {})
+      establish_database_connection
+      enable_plugins
+      enable_query_logging if ENV['ENABLE_SQL_LOGGING']
+    end
+
+    def establish_database_connection
+      connect
+    rescue Sequel::DatabaseConnectionError
+      log.warn "Database requires initialization"
+      init_database
+      retry if ConnectionAttempts.memo < 2
+    end
+
+    def database_config
+      @database_config ||= YAML.load_file(database_config_file_path)
+    end
+
+    def database_config_file_path
+      @database_config_file_path ||= File.expand_path(
+        File.join(Inform::Runtime.project_dir_path, 'config', 'database.yml')
+      )
+    end
+
+    def init_database
+      @config = database_config.fetch('default')
+      connect
+      @database = Inform::Database.instance(Inform::Game.config[:database_name])
+      @database.bootstrap.up
+      @config = database_config.fetch(environment.to_s)
+      connect
+    end
+  end
+  # class Persistence
+end
+# module Inform
+
+# The Inform module
+module Inform
+  # The ImplicitMigration module
+  module ImplicitMigration
+    NoDatabasePattern = %r{No database associated with Sequel::Model}.freeze
+    MigrationSetupTemplate = '%<model>sSetup'.freeze
+    ModuleNamespaceDelimiterPattern = /::/.freeze
+
+    def before_inherited(subclass)
+      return if self != Sequel::Model
+      descendants << subclass
+      log.debug "#{subclass} << #{self} [#{descendants}]"
+      maybe_migrate(subclass)
+    end
+
+    def after_inherited(_subclass)
+      examine_schema
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def examine_schema
+      descendants.each do |model_class|
+        table_name = model_class.table_name
+        indexes = self.db.indexes(table_name)
+        columns = model_class.columns
+        associations = model_class.associations
+
+        log.debug "Table: #{table_name}"
+        log.debug "Columns: #{columns.join(', ')}"
+        log.debug "Indexes: #{indexes}"
+
+        associations.each do |assoc_name, assoc_data|
+          log.debug "Association: #{assoc_name} (#{assoc_data[:type]}) to #{assoc_data[:class_name]}"
+        end
+
+        log.debug "==========="
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def maybe_migrate(subclass)
+      migration_class = migration(subclass)
+      log.debug "Found migration class: #{migration_class}"
+      migration_class&.up
+    rescue Sequel::Error => e
+      if NoDatabasePattern.match?(e.message)
+        Inform::Persistence.instance.connect
+        retry
+      end
+    end
+
+    def migration(model)
+      names = format(MigrationSetupTemplate, model: model).split(ModuleNamespaceDelimiterPattern)
+      names.inject(Object) do |mod, class_name|
+        mod.const_get(class_name)
+      rescue StandardError => e
+        log.warn "Error getting reference to migration model class: #{e.message}"
+        next
+      end
+    end
+  end
+  # module ImplicitMigration
+end
+# module Inform
+
+# The Inform module
+module Inform
+  # The InheritanceListener module
+  module InheritanceListener
+    # The ClassMethods module
+    module ClassMethods
+      include Inform::ImplicitMigration
+
+      def inherited(subclass)
+        before_inherited(subclass)
+        super
+        after_inherited(subclass)
+      end
+
+      # Returns the list of Model descendants.
+      def descendants
+        @descendants ||= []
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+  # module InheritanceListener
+end
+# module Inform
+
+# The Sequel module
+module Sequel
+  # The Sequel::Model class
+  class Model
+    include Inform::InheritanceListener
+
+    def self.implicit_table_name
+      underscore(demodulize(name)).to_sym
+    end
+  end
+end

data/lib/runtime/plurals.rb

@@ -0,0 +1,60 @@
+# 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 'inflector'
+
+# The Inform module
+module Inform
+  # The Plurals module
+  module Plurals
+    # Returns the plural form of the word in the string.
+    def pluralize(word, n = nil)
+      return word if n == 1
+      apply_inflections(word, Inform::Inflector.inflections.plurals)
+    end
+
+    # The reverse of +pluralize+, returns the singular form of a word in a
+    # string.
+    def singularize(word)
+      apply_inflections(word, Inform::Inflector.inflections.singulars)
+    end
+
+    def singular?(s)
+      singularize(s) == s
+    end
+
+    def plural?(s)
+      pluralize(s) == s
+    end
+
+    # Applies inflection rules for +singularize+ and +pluralize+.
+    def apply_inflections(word, rules)
+      return "" if word.empty?
+      result = word.to_s.dup
+      return result if Inform::Inflector.inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
+      for (rule, replacement) in rules
+        break if result.sub!(rule, replacement)
+      end
+      result
+    end
+  end
+  # module Plurals
+end
+# module Inform