inform-runtime 1.2.2 → 1.3.1

data/lib/story_teller/logging.rb

@@ -2,7 +2,7 @@
 # encoding: utf-8
 # frozen_string_literal: false
 
-# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+# Copyright Nels Nelson 2008-2026 but freely usable (see license)
 #
 # This file is part of StoryTeller.
 #
@@ -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/mixins.rb

@@ -1,7 +1,8 @@
+# lib/story_teller/mixins.rb
 # encoding: utf-8
 # frozen_string_literal: false
 
-# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+# Copyright Nels Nelson 2008-2026 but freely usable (see license)
 #
 # This file is part of StoryTeller.
 #
@@ -456,9 +457,15 @@ class Array
     end
   end
 
-  def sum(&block)
-    return inject(0, &block) if block_given?
-    inject(:+)
+  def sum(init = nil)
+    if block_given?
+      initial = init.nil? ? 0 : init
+      inject(initial) { |total, element| total + yield(element) }
+    elsif init.nil?
+      inject(:+)
+    else
+      inject(init, :+)
+    end
   end
 
   def average

data/lib/story_teller/plurals.rb

@@ -1,7 +1,8 @@
+# lib/story_teller/plurals.rb
 # encoding: utf-8
 # frozen_string_literal: false
 
-# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+# Copyright Nels Nelson 2008-2026 but freely usable (see license)
 #
 # This file is part of the StoryTeller.
 #

data/lib/story_teller/privileges.rb

@@ -0,0 +1,117 @@
+# lib/story_teller/privileges.rb
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2026 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/>.
+
+# module StoryTeller
+module StoryTeller
+  # module PrivilegedIdentity
+  module PrivilegedIdentity
+    def privilege?(_privilege)
+      false
+    end
+
+    def privilege_label
+      to_s
+    end
+  end
+
+  # The StoryTeller::Privileges module to implement privilege
+  module Privileges
+    class << self
+      def privileged?(subject, privilege)
+        StoryTeller::PrivilegeGrants.granted?(subject, privilege)
+      end
+
+      def subject_for(subject)
+        session_for(subject) || subject
+      end
+
+      private
+
+      def session_for(subject)
+        return nil if subject.nil?
+        return nil unless defined?(StoryTeller::IO::Session)
+        return subject if subject.is_a?(StoryTeller::IO::Session)
+        return subject.instance_variable_get(:@session) if subject.instance_variable_defined?(:@session)
+
+        StoryTeller::IO::Session.of(subject)
+      end
+    end
+
+    def privileged?(privilege, subject = self)
+      StoryTeller::Privileges.privileged?(subject, privilege)
+    end
+  end
+
+  # module PrivilegeGrants
+  module PrivilegeGrants
+    @session_grants = Hash.new { |hash, key| hash[key] = Set.new }
+    @mode = :persistent
+
+    class << self
+      attr_accessor :mode
+
+      def grant_session(subject, privilege)
+        subject = StoryTeller::Privileges.subject_for(subject)
+        return nil if subject.nil?
+
+        @session_grants[identity(subject)].add(privilege.to_sym)
+      end
+
+      def session_granted?(subject, privilege)
+        subject = StoryTeller::Privileges.subject_for(subject)
+        return false if subject.nil?
+
+        @session_grants[identity(subject)].include?(privilege.to_sym)
+      end
+
+      def persistent_granted?(subject, privilege)
+        subject = StoryTeller::Privileges.subject_for(subject)
+        return false unless subject.is_a?(StoryTeller::PrivilegedIdentity)
+
+        subject.privilege?(privilege.to_sym)
+      end
+
+      def granted?(subject, privilege)
+        privilege = privilege.to_sym
+
+        session_granted?(subject, privilege) ||
+          (privilege == :builder && session_granted?(subject, :admin)) ||
+          persistent_granted_under_mode?(subject, privilege)
+      end
+
+      private
+
+      def persistent_granted_under_mode?(subject, privilege)
+        return false if mode == :session_only
+
+        persistent_granted?(subject, privilege) ||
+          (privilege == :builder && persistent_granted?(subject, :admin))
+      end
+
+      def identity(subject)
+        return subject.identity if subject.respond_to?(:identity)
+
+        subject.object_id
+      end
+    end
+  end
+end
+# module StoryTeller