Updated console message code to Luka's latest version

2025-12-07 21:24:59 +00:00 · 2021-11-21 17:36:25 +00:00
parent b445f26a88
commit ea9cacd6b9
9 changed files with 173 additions and 151 deletions
--- a/Data/Scripts/001_Technical/001_Debugging/002_DebugConsole.rb
+++ b/Data/Scripts/001_Technical/001_Debugging/002_DebugConsole.rb
@@ -1,6 +1,6 @@
-# To use the console, use the executable explicitly built
-# with the console enabled on Windows. On Linux and macOS,
-# just launch the executable directly from a terminal.
+# To use the console, use the executable explicitly built with the console
+# enabled on Windows. On Linux and macOS, just launch the executable directly
+# from a terminal.
 module Console
  def self.setup_console
    return unless $DEBUG
@@ -51,147 +51,169 @@ Console.setup_console
 #===============================================================================
 #  Console message formatting
 #===============================================================================
-module ConsoleRGB
-  # string colors
-  CMD_COLORS = {
-    default: '38', black: '30', red: '31', green: '32', brown: '33', blue: '34',
-    purple: '35', cyan: '36', gray: '37',
-    dark_gray: '1;30', light_red: '1;31', light_green: '1;32', yellow: '1;33',
-    light_blue: '1;34', light_purple: '1;35', light_cyan: '1;36', white: '1;37'
-  }
-  # background colors
-  CMD_BG_COLORS = {
-    default: '0', black: '40', red: '41', green: '42', brown: '43', blue: '44',
-    purple: '45', cyan: '46', gray: '47',
-    dark_gray: '100', light_red: '101', light_green: '102', yellow: '103',
-    light_blue: '104', light_purple: '105', light_cyan: '106', white: '107'
-  }
-  # font options
-  CMD_FONT_OPTIONS = {
-    bold: '1', dim: '2', italic: '3', underline: '4', reverse: '7', hidden: '8'
-  }
-  # syntax highlighting based on markup
-  CMD_SYNTAX_COLOR = {
-    '`' => :cyan, '"' => :purple, "'" => :purple, '$' => :green, '~' => :red
-  }
-  # syntax options based on markup
-  CMD_SYNTAX_OPTIONS = {
-    '*' => :bold, '|' => :italic, '__' => :underline
-  }
+module Console
+  module_function

  #-----------------------------------------------------------------------------
-  #  apply console coloring
-  #-----------------------------------------------------------------------------
-  def self.colors(string, text: :default, bg: :default, **options)
-    # get colors
-    code_text = CMD_COLORS[text]
-    code_bg   = CMD_BG_COLORS[bg]
-    # get options
-    option_pool = options.select { |key, val| CMD_FONT_OPTIONS.key?(key) && val }
-    font_options = option_pool.keys.map { |opt| CMD_FONT_OPTIONS[opt] }.join(';').squeeze
-    # return formatted string
-    return "\e[#{code_bg};#{font_options};#{code_text}m#{string}\e[0m".squeeze(';')
-  end
-
-  #-----------------------------------------------------------------------------
-  #  character markup to color mapping for console
-  #-----------------------------------------------------------------------------
-  # component level
-  def self.markup_component(string, options = {})
-    # syntax markup format options
-    [CMD_SYNTAX_COLOR, CMD_SYNTAX_OPTIONS].each_with_index do |hash, i|
-      hash.each do |key, value|
-        l = key.length
-        # ensure escape
-        key = key.chars.map { |c| "\\#{c}" }.join
-        # define regex
-        regex = "#{key}.*?#{key}"
-        # match markup
-        string.scan(/#{regex}/).each do |cpt|
-          options[i == 0 ? :text : value] = i == 0 ? value : true
-          options, string = self.markup_component(cpt[l...-l], options)
-        end
-      end
-    end
-    return options, string
-  end
-
-  # full string
-  def self.markup(string)
-    final_options = {}
-    (CMD_SYNTAX_COLOR.merge(CMD_SYNTAX_OPTIONS)).each_key do |key|
-      # ensure escape
-      key = key.chars.map { |c| "\\#{c}" }.join
-      # define regex
-      regex = "#{key}.*?#{key}"
-      string.scan(/#{regex}/).each do |cpt|
-        options, clean = self.markup_component(cpt)
-        if final_options[clean]
-          final_options[clean].deep_merge!(options)
-        else
-          final_options[clean] = options.clone
-        end
-        string.gsub!(cpt, clean)
-      end
-    end
-    # iterate through final options and apply them
-    final_options.each do |key, opt|
-      string.gsub!(key, self.colors(key, **opt))
-    end
-    return string
-  end
-
-  #-----------------------------------------------------------------------------
-  #  echo string into console (example short hand for common options)
+  #  echo string into console (example shorthand for common options)
  #-----------------------------------------------------------------------------
  # heading 1
-  def self.echo_h1(msg)
-    echoln ConsoleRGB.colors("*** #{msg} ***\r\n", text: :brown)
+  def echo_h1(msg)
+    echoln markup_style("*** #{msg} ***", text: :brown)
+    echoln ""
  end

  # heading 2
-  def self.echo_h2(msg, **options)
-    echoln ConsoleRGB.colors("#{msg}\r\n", **options)
+  def echo_h2(msg, **options)
+    echoln markup_style(msg, **options)
+    echoln ""
  end

  # heading 3
-  def self.echo_h3(msg)
-    echoln ConsoleRGB.markup("#{msg}\r\n")
+  def echo_h3(msg)
+    echoln markup(msg)
+    echoln ""
  end

  # list item
-  def self.echo_li(msg)
-    echo ConsoleRGB.colors("  -> ", text: :brown)
-    echo ConsoleRGB.markup(msg)
+  def echo_li(msg, pad = 0, color = :brown)
+    echo markup_style('  -> ', text: color)
+    pad = (pad - msg.length) > 0 ? '.' * (pad - msg.length) : ''
+    echo markup(msg + pad)
  end

-  # list item (ends the line)
-  def self.echoln_li(msg)
-    self.echo_li(msg + "\r\n")
+  # list item with line break after
+  def echoln_li(msg, pad = 0, color = :brown)
+    self.echo_li(msg, pad, color)
+    echoln ""
  end

  # paragraph with markup
-  def self.echo_p(msg)
-    echoln ConsoleRGB.markup(msg)
+  def echo_p(msg)
+    echoln markup(msg)
  end

  # warning message
-  def self.echo_warn(msg)
-    echoln ConsoleRGB.colors("WARNING: " + msg, text: :yellow)
+  def echo_warn(msg)
+    echoln markup_style("WARNING: #{msg}", text: :yellow)
  end

  # error message
-  def self.echo_error(msg)
-    echoln ConsoleRGB.colors("ERROR: " + msg, text: :light_red)
+  def echo_error(msg)
+    echoln markup_style("ERROR: #{msg}", text: :light_red)
  end

  # status output
-  def self.echo_status(status)
-    echoln status ? ConsoleRGB.colors('OK', text: :green) : ConsoleRGB.colors('FAIL', text: :red)
+  def echo_status(status)
+    echoln (status) ? markup_style('OK', text: :green) : markup_style('FAIL', text: :red)
  end

  # completion output
-  def self.echo_complete(status)
-    echoln status ? ConsoleRGB.colors('done', text: :green) : ConsoleRGB.colors('error', text: :red)
+  def echo_done(status)
+    echoln (status) ? markup_style('done', text: :green) : markup_style('error', text: :red)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Markup options
+  #-----------------------------------------------------------------------------
+  def string_colors
+    {
+      default: '38', black: '30', red: '31', green: '32', brown: '33',
+      blue: '34', purple: '35', cyan: '36', gray: '37',
+      dark_gray: '1;30', light_red: '1;31', light_green: '1;32', yellow: '1;33',
+      light_blue: '1;34', light_purple: '1;35', light_cyan: '1;36', white: '1;37'
+    }
+  end
+
+  def background_colors
+    {
+      default: '0', black: '40', red: '41', green: '42', brown: '43',
+      blue: '44', purple: '45', cyan: '46', gray: '47',
+      dark_gray: '100', light_red: '101', light_green: '102', yellow: '103',
+      light_blue: '104', light_purple: '105', light_cyan: '106', white: '107'
+    }
+  end
+
+  def font_options
+    {
+      bold: '1', dim: '2', italic: '3', underline: '4', reverse: '7',
+      hidden: '8'
+    }
+  end
+
+  # Text markup that turns text between them a certain color
+  def markup_colors
+    {
+      '`' => :cyan, '"' => :purple, "'" => :purple, '$' => :green, '~' => :red
+    }
+  end
+
+  def markup_options
+    {
+      '__' => :underline, '*' => :bold, '|' => :italic
+    }
+  end
+
+  # apply console coloring
+  def markup_style(string, text: :default, bg: :default, **options)
+    # get colors
+    code_text = string_colors[text]
+    code_bg   = background_colors[bg]
+    # get options
+    options_pool = options.select { |key, val| font_options.key?(key) && val }
+    markup_pool  = options_pool.keys.map { |opt| font_options[opt] }.join(';').squeeze
+    # return formatted string
+    "\e[#{code_bg};#{markup_pool};#{code_text}m#{string}\e[0m".squeeze(';')
+  end
+
+  #-----------------------------------------------------------------------------
+  # Perform markup on text
+  #-----------------------------------------------------------------------------
+
+  def markup_all_options
+    @markup_all_options ||= markup_colors.merge(markup_options)
+  end
+
+  def markup_component(string, component, key, options)
+    # trim inner markup content
+    l = key.length
+    trimmed = component[l...-l]
+    # merge markup options
+    options[trimmed] = {} unless options[trimmed]
+    options[trimmed].deep_merge!({}.tap do |new_opt|
+      new_opt[:text] = markup_colors[key] if markup_colors.key?(key)
+      new_opt[markup_options[key]] = true if markup_options.key?(key)
+    end)
+    # remove markup from input string
+    string.gsub!(component, trimmed)
+    # return output
+    return string, options
+  end
+
+  def markup_breakdown(string, options = {})
+    # iterate through all options
+    markup_all_options.each_key do |key|
+      # ensure escape
+      key_char = key.chars.map { |c| "\\#{c}" }.join
+      # define regex
+      regex = "#{key_char}.*?#{key_char}"
+      # go through matches
+      string.scan(/#{regex}/).each do |component|
+        return *markup_breakdown(*markup_component(string, component, key, options))
+      end
+    end
+    # return output
+    return string, options
+  end
+
+  def markup(string)
+    # get a breakdown of all markup options
+    string, options = markup_breakdown(string)
+    # iterate through each option and apply
+    options.each do |key, opt|
+      string.gsub!(key, markup_style(key, **opt))
+    end
+    # return string
+    return string
  end
 end
--- a/Data/Scripts/001_Technical/001_Debugging/005_Deprecation.rb
+++ b/Data/Scripts/001_Technical/001_Debugging/005_Deprecation.rb
@@ -15,7 +15,7 @@ module Deprecation
    unless alternative.nil?
      text += "\r\n" + _INTL("Use \"{1}\" instead.", alternative)
    end
-    ConsoleRGB.echo_warn text
+    Console.echo_warn text
  end
 end

--- a/Data/Scripts/001_Technical/005_PluginManager.rb
+++ b/Data/Scripts/001_Technical/005_PluginManager.rb
@@ -352,7 +352,7 @@ module PluginManager
  def self.error(msg)
    Graphics.update
    t = Thread.new do
-      ConsoleRGB.echo_error "Plugin Error:\r\n#{msg}"
+      Console.echo_error "Plugin Error:\r\n#{msg}"
      p "Plugin Error: #{msg}"
      Thread.exit
    end
@@ -659,7 +659,7 @@ module PluginManager
  # Check if plugins need compiling
  #-----------------------------------------------------------------------------
  def self.compilePlugins(order, plugins)
-    ConsoleRGB.echo_li "Compiling plugin scripts..."
+    Console.echo_li "Compiling plugin scripts..."
    scripts = []
    # go through the entire order one by one
    for o in order
@@ -681,13 +681,13 @@ module PluginManager
    File.open("Data/PluginScripts.rxdata", 'wb') { |f| Marshal.dump(scripts, f) }
    # collect garbage
    GC.start
-    ConsoleRGB.echo_complete(true)
+    Console.echo_done(true)
  end
  #-----------------------------------------------------------------------------
  # Check if plugins need compiling
  #-----------------------------------------------------------------------------
  def self.runPlugins
-    ConsoleRGB.echo_h1 "Checking plugins"
+    Console.echo_h1 "Checking plugins"
    # get the order of plugins to interpret
    order, plugins = self.getPluginOrder
    # compile if necessary
@@ -699,7 +699,7 @@ module PluginManager
      # get the required data
      name, meta, script = plugin
      if !meta[:essentials] || !meta[:essentials].include?(Essentials::VERSION)
-        ConsoleRGB.echo_warn "Plugin '#{name}' may not be compatible with Essentials v#{Essentials::VERSION}. Trying to load anyway."
+        Console.echo_warn "Plugin '#{name}' may not be compatible with Essentials v#{Essentials::VERSION}. Trying to load anyway."
      end
      # register plugin
      self.register(meta)
@@ -715,7 +715,7 @@ module PluginManager
        # try to run the code
        begin
          eval(code, TOPLEVEL_BINDING, fname)
-          ConsoleRGB.echoln_li "Loaded plugin: '#{name}'" if !echoed_plugins.include?(name)
+          Console.echoln_li "Loaded plugin: '#{name}'" if !echoed_plugins.include?(name)
          echoed_plugins.push(name)
        rescue Exception   # format error message to display
          self.pluginErrorMsg(name, sname)
@@ -725,9 +725,9 @@ module PluginManager
    end
    if scripts.length > 0
      echoln ""
-      ConsoleRGB.echo_h2("Successfully loaded #{scripts.length} plugin(s)", text: :green)
+      Console.echo_h2("Successfully loaded #{scripts.length} plugin(s)", text: :green)
    else
-      ConsoleRGB.echo_h2("No plugins found", text: :green)
+      Console.echo_h2("No plugins found", text: :green)
    end
  end
  #-----------------------------------------------------------------------------