inform-runtime 1.0.4

data/lib/runtime/link.rb

@@ -0,0 +1,158 @@
+# 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/>.
+
+# Link
+
+if defined?(Sequel::Migration)
+# The LinkSetup class
+class LinkSetup < Sequel::Migration
+  # rubocop: disable Metrics/MethodLength
+  def up
+    # return if table_exists? :link
+    log.debug "#up"
+    create_table? :link do
+      primary_key :id
+      foreign_key :from_id, :object, on_delete: :cascade
+      foreign_key :to_id, :object, on_delete: :cascade
+      index :name
+      index :created_at
+
+      String :name
+      DateTime :created_at
+      DateTime :modified_at
+    end
+  end
+  # rubocop: enable Metrics/MethodLength
+
+  def down
+    drop_table :link if table_exists? :link
+  end
+end
+# class LinkSetup
+end
+# defined?(Sequel::Migration)
+
+# The Inform module
+module Inform
+  # The Inform::Link class
+  class Link < Sequel::Model
+    set_primary_key :id
+    def_column_accessor :created_at, :modified_at
+    def_column_accessor :name
+    many_to_one :from, class: Inform::Object, key: :from_id
+    many_to_one :to,   class: Inform::Object, key: :to_id
+
+    LinkTemplate = '%<link_name>s -> %<to_name>s [%<to_identity>s]'.freeze
+    LinkMethods = %w[from_id to_id].freeze
+    MethodWriterTemplate = '%<method_name>s='.freeze
+
+    def before_create
+      self.created_at ||= Time.now
+      super
+    end
+
+    def after_save
+      super
+      self.modified_at = Time.now.utc
+    end
+
+    def to_s
+      format(LinkTemplate, link_name: name, to_name: to.name, to_identity: to.identity)
+    end
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def init_with(coder)
+      LinkMethods.each do |method_name|
+        method_symbol = format(MethodWriterTemplate, method_name: method_name).to_sym
+        self.send(method_symbol, coder[method_name]) if self.respond_to? method_symbol
+      end
+      self
+    end
+  end
+end
+
+# The Inform module
+module Inform
+  # The Linkable module
+  module Linkable
+    def links
+      super
+    rescue StandardError => _e
+      Array::Empty
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def link(link_name, obj = nil)
+      link = Inform::Link.first(name: link_name.to_s, from_id: self.id)
+      link&.to&.refresh
+      return link if obj.nil?
+      if link.nil?
+        clauses = { name: link_name.to_s, from_id: self.id, to_id: obj.id }
+        link = Inform::Link.find_or_create(**clauses) do |l|
+          l.from = self
+          l.to = obj
+        end
+      else
+        link.to = obj
+        link.save
+      end
+      link
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def linked?(link_name)
+      Inform::Link.filter(name: link_name.to_s, from_id: self.id).count > 0
+    end
+
+    def unlink(link_name)
+      Inform::Link.first(name: link_name.to_s, from_id: self.id).destroy&.to
+    rescue Sequel::NoExistingObject => e
+      log.warn 'Error: ' + e.message
+      log.warn 'No such link: ' + link_name
+      nil
+    end
+
+    def linkto(link_name)
+      Inform::Link.first(name: link_name.to_s, from_id: self.id)&.to&.refresh
+    end
+
+    def linksfrom(link_name = nil)
+      if link_name.nil?
+        Inform::Link.filter(to_id: self.id).map(&:from)
+      else
+        Inform::Link.filter(name: link_name.to_s, to_id: self.id).map(&:from)
+      end
+    end
+
+    alias _key? linked?
+    alias _get_object linkto
+    def _set_object(link_name, obj = nil)
+      link(link_name, obj).to
+    end
+    alias _unset_object unlink
+  end
+  # module Linkable
+end
+# module Inform

data/lib/runtime/logging.rb

@@ -0,0 +1,197 @@
+# 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 'fileutils'
+require 'logger'
+
+if defined?(Java)
+require 'apache-log4j-2'
+end
+
+# The Logging module
+module Logging
+  # 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))
+      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"))
+      {
+        level: :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",
+        logging_timestamp_format: '%Y-%m-%d %H:%M:%S',
+        logging_pattern_template: {
+          java: '%d{ABSOLUTE} %-5p [%c{1}] %m%n',
+          ruby: "%<timestamp>s %-5<severity>s [%<progname>s] %<msg>s\n"
+        },
+        schedule: '0 0 0 * * ?',
+        size: '100M'
+      }
+    end
+  end
+  module_function :config
+  # rubocop: enable Metrics/MethodLength
+end
+
+# Namespace for methods to help with implicit backtrace printing
+module LoggerHelpers
+  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
+
+  def extract_backtrace(error, default_result = nil)
+    if error.respond_to?(:backtrace)
+      error.backtrace.each { |trace| original_error(trace) unless trace.nil? }
+    elsif error.respond_to?(:getStackTrace)
+      error.getStackTrace().each { |trace| original_error(trace) unless trace.nil? }
+    else
+      default_result
+    end
+  end
+end
+
+# Monkey-patch the built-in Ruby Logger class to support
+# implicit backtrace printing
+# TODO: Figure out if this is actually useful.
+class Logger
+  include LoggerHelpers
+
+  alias original_error error
+  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))
+  end
+end
+
+# The Logging module
+module Logging
+  if defined?(Java)
+  java_import Java::org.apache.logging.log4j.Level
+  java_import Java::org.apache.logging.log4j.LogManager
+  end
+
+  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])
+  end
+
+  def ruby_log_formatter(severity, datetime, progname, message)
+    format(
+      Logging.config[:logging_pattern_template][:ruby],
+      timestamp: datetime.strftime(Logging.config[:logging_timestamp_format]),
+      progname: progname, severity: severity, msg: message)
+  end
+
+  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)
+    log.level = level.to_s unless level.nil?
+    log.formatter = method(:ruby_log_formatter)
+    log
+  end
+
+  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?
+    log = LogManager.getLogger(logger_name)
+    log.level = Level.to_level(level.to_s.upcase) unless level.nil?
+    log
+  end
+
+  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+$/]
+  end
+
+  # rubocop: disable Metrics/CyclomaticComplexity
+  # OFF: 0
+  # FATAL: 100
+  # ERROR: 200
+  # WARN: 300
+  # INFO: 400
+  # DEBUG: 500
+  # TRACE: 600
+  # ALL: 2147483647
+  # See: https://logging.apache.org/log4j/2.x/log4j-api/apidocs/org/apache/logging/log4j/Level.html
+  def symbolize_numeric_log_level(level)
+    case level
+    when 5..Float::INFINITY then :off
+    when 4 then :fatal
+    when 3 then :error
+    when 2 then :warn
+    when 1 then :info
+    when 0 then :debug
+    when -1 then :trace
+    when -Float::INFINITY..-2 then :all
+    end
+  end
+  # rubocop: enable Metrics/CyclomaticComplexity
+
+  def log_level=(level)
+    Logging.config[:level] = symbolize_numeric_log_level(level)
+  end
+  module_function :log_level=
+
+  def log_level
+    Logging.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)
+  end
+  alias logger log
+end
+# module Logging
+
+# The Module class
+class Module
+  # Universally include Logging
+  include ::Logging
+end
+
+# The Class class
+class Class
+  # Universally include Logging
+  include ::Logging
+end
+
+# The Object class
+class Object
+  # Universally include Logging
+  include ::Logging
+end