rbcli 0.3.2 → 0.4.0

data/lib/rbcli/components/logger/logger.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+%w(logger json colorize).each { |req| require req }
+require_relative 'lolcat/lol'
+
+# noinspection RubyClassVariableUsageInspection
+class Rbcli::Logger
+  EXECUTABLE ||= File.basename($0).gsub(/\.[^.]+$/, '')
+  @max_prog_len = 0
+  @original_formatter = Logger::Formatter.new
+  @@formatters = {
+    display: Proc.new { |severity, _datetime, _progname, msg|
+      severity == 'INFO' ? msg : "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{msg}"
+    },
+    simple: Proc.new { |severity, _datetime, progname, msg|
+      @max_prog_len = (@max_prog_len > progname.length) ? @max_prog_len : progname.length unless progname.nil?
+      "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{progname || (' ' * @max_prog_len)} || #{msg}"
+    },
+    full: Proc.new { |severity, datetime, progname, msg|
+      @max_prog_len = (@max_prog_len > progname.length) ? @max_prog_len : progname.length unless progname.nil?
+      "#{datetime.strftime("%Y-%m-%d %H:%M:%S.%6N")} || #{EXECUTABLE} || #{progname || (' ' * @max_prog_len)} || #{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{msg}"
+    },
+    apache: Proc.new { |severity, datetime, progname, msg|
+      "[#{datetime.strftime("%a %b %d %H:%M:%S.%6N %Y")}] [#{severity}] [#{EXECUTABLE}] [#{progname}] #{msg.gsub(/\e\[([;\d]+)?m/, '')}"
+    },
+    json: Proc.new { |severity, datetime, progname, msg|
+      { timestamp: datetime.strftime("%Y-%m-%d %H:%M:%S.%N"), severity: severity, application: EXECUTABLE, module: progname, message: msg.gsub(/\e\[([;\d]+)?m/, '') }.to_json
+    },
+    ruby: Proc.new { |severity, datetime, progname, msg|
+      @original_formatter.call(severity, datetime, progname, msg).chomp
+    },
+    lolcat: Proc.new { |severity, _datetime, _progname, msg|
+      "#{colorlevel(severity)}#{(' ' * (5 - severity.length))} || #{Lol.makestr(msg, { spread: 3, freq: 0.1, slope: 4, invert: false, truecolor: true })}"
+    }
+  }
+
+  def self.formats
+    @@formatters.keys
+  end
+
+  def initialize(target: STDOUT, level: :info, format: :display)
+    self.target(target)
+    self.level(level)
+    self.format(format)
+  end
+
+  def target target
+    @logger = Logger.new(target_select(target))
+    @logger.formatter = Proc.new { |severity, datetime, progname, msg|
+      msg = msg.to_s unless msg.is_a?(String)
+      msg.lines.map { |line| @@formatters[@format].call(severity, datetime, progname, line.chomp) }.join("\n") + "\n"
+    }
+  end
+
+  def level slug = nil
+    return @logger.level if slug.nil?
+    @logger.level = logger_level(slug)
+  end
+
+  def format slug = nil
+    return @format if slug.nil?
+    @format = slug if @@formatters.key?(slug)
+  end
+
+  def add_format slug, prok
+    @@formatters[slug] = prok
+  end
+
+  def add level, message, progname = nil, &block
+    @logger.add(logger_level(level), message, progname, &block)
+  end
+
+  def debug message, progname = nil, &block
+    self.add(Logger::DEBUG, message, progname, &block)
+  end
+
+  def info message, progname = nil, &block
+    self.add(Logger::INFO, message, progname, &block)
+  end
+
+  def warn message, progname = nil, &block
+    self.add(Logger::WARN, message, progname, &block)
+  end
+
+  def error message, progname = nil, &block
+    self.add(Logger::ERROR, message, progname, &block)
+  end
+
+  def fatal message, progname = nil, &block
+    self.add(Logger::FATAL, message, progname, &block)
+  end
+
+  def unknown message, progname = nil, &block
+    self.add(Logger::UNKNOWN, message, progname, &block)
+  end
+
+  %w(debug, info, warn, error, fatal, unknown).each do |l|
+    self.define_method(l.to_sym) do |message, progname = nil, &block|
+      self.send(:add, l.to_sym, message, progname, &block)
+    end
+  end
+
+  private
+
+  def self.colorlevel level
+    level.colorize(
+      {
+        'DEBUG' => :blue,
+        'INFO' => :green,
+        'WARN' => :yellow,
+        'ERROR' => :red,
+        'FATAL' => { color: :light_red, mode: :bold },
+        'ANY' => :cyan
+      }[level.to_s.upcase] || :default)
+  end
+
+  def target_select slug
+    {
+      stdout: STDOUT,
+      stderr: STDERR
+    }[slug] || slug
+  end
+
+  def logger_level slug
+    if slug.is_a?(String) || slug.is_a?(Symbol)
+      {
+        debug: Logger::DEBUG,
+        info: Logger::INFO,
+        warn: Logger::WARN,
+        error: Logger::ERROR,
+        fatal: Logger::FATAL,
+        unknown: Logger::UNKNOWN,
+        any: -1
+      }[slug.to_s.downcase.to_sym] || Logger::UNKNOWN
+    else
+      slug
+    end
+  end
+end
+
+module Rbcli
+  @logger = nil
+
+  def self.start_logger target: STDOUT, level: :info, format: :display
+    @logger = Rbcli::Logger.new(target: target, level: level, format: format)
+  end
+
+  def self.log
+    self.start_logger if @logger.nil?
+    @logger
+  end
+end

data/lib/rbcli/components/logger/lolcat/lol.rb

@@ -0,0 +1,71 @@
+# This file was obtained and modified from: https://github.com/busyloop/lolcat/blob/master/lib/lolcat/lol.rb
+
+# Copyright (c) 2016, moe@busyloop.net
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of the lolcat nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'paint'
+
+module Lol
+  ANSI_ESCAPE = /((?:\e(?:[ -\/]+.|[\]PX^_][^\a\e]*|\[[0-?]*.|.))*)(.?)/m
+
+  @os = 0
+  @paint_init = false
+
+  def self.makestr(str, opts = {})
+    @os = rand(256) unless @paint_init
+    set_mode(opts[:truecolor]) unless @paint_init
+
+    result = ''
+    filtered = str.scan(ANSI_ESCAPE)
+    filtered.each_with_index do |c, i|
+      # color = rainbow(opts[:freq], @os + i / opts[:spread])
+      color = rainbow(opts[:freq], (@os + i) / opts[:spread])
+      if opts[:invert] then
+        result += c[0] + Paint.color(nil, color) + c[1] + "\e[49m"
+      else
+        result += c[0] + Paint.color(color) + c[1] + "\e[39m"
+      end
+    end
+    @os += opts[:slope]
+    result
+  end
+
+  private
+
+  def self.set_mode(truecolor)
+    # @paint_mode_detected = Paint.mode
+    @paint_mode_detected = %w[truecolor 24bit].include?(ENV['COLORTERM']) ? 0xffffff : 256
+    Paint.mode = truecolor ? 0xffffff : @paint_mode_detected
+    STDERR.puts "DEBUG: Paint.mode = #{Paint.mode} (detected: #{@paint_mode_detected})" if ENV['LOLCAT_DEBUG']
+    @paint_init = true
+  end
+
+  def self.rainbow(freq, i)
+    red = Math.sin(freq * i + 0) * 127 + 128
+    green = Math.sin(freq * i + 2 * Math::PI / 3) * 127 + 128
+    blue = Math.sin(freq * i + 4 * Math::PI / 3) * 127 + 128
+    "#%02X%02X%02X" % [red, green, blue]
+  end
+end

data/lib/rbcli/components/logger/template.rb.erb

@@ -0,0 +1,40 @@
+Rbcli::Configurate.logger do
+  <%- if @showdocs -%>
+  ##### Logger (Optional) #####
+  # The Rbcli logger is a wrapper around the standard Ruby `Logger` library
+  # It is recommended that - unless you want to use specialized output libraries (such as ncurses) - that all
+  #    of your application output is directed through the logger. This will allow for easy formatting and redirection
+  #    no matter how your application is run.
+  #
+  # Valid targets are: :stdout, :stderr, "/path/to/a/file", or an IO or StringIO object   (Default: :stdout)
+  # Valid levels are: :debug, :info, :warn, :error, :fatal, :unknown, :any                (Default: :info)
+  # Valid formats are: :display, :simple, :full, :ruby, :json, :apache, :lolcat           (Default: :display)
+  #
+  # The first three formats are designed to cover most use cases:
+  #   display:   For display on a terminal, with user interaction
+  #   simple:    For display on a terminal, for a developer
+  #   full:      For logging to a file, or using log collection software
+  # The next three are for specialized integrations in case you already have log collection configured:
+  #   ruby:      Default ruby logger format
+  #   json:      Each line is a JSON object
+  #   apache:    Follows the standard Apache log format
+  # As for :lolcat... if you can't guess what it does then give it a shot
+  <%- end -%>
+  logger target: :stdout, level: :info, format: :display
+  <%- if @showdocs -%>
+  # Custom formats can also be defined here.
+  # Declaring a format here will not switch to it. However, if
+  # the `format` keyword is used without providing a Proc, it will switch
+  # to that format.
+  #
+  #   Format switch:      format :json
+  #   Format definition:  format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+  #
+  # You can also switch formats mid-execution by calling this method on
+  # the logger object itself.
+  #
+  #   Rbcli.log.format :json
+  #
+  <%- end -%>
+  # format :foo, Proc.new { |severity, datetime, progname, msg| "Foo! " + msg }
+end

data/lib/rbcli/components/parser/component.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+module Rbcli::Configurate::Cli
+  include Rbcli::Configurable
+
+  @defaults = {
+    appinfo: {
+      appname: EXECUTABLE,
+      version: nil,
+      author: nil,
+      email: nil,
+      copyright_year: nil,
+      license: nil,
+      helptext: nil
+    }
+  }
+
+  @defaults.keys.each do |namespace|
+    @defaults[namespace].each do |key, default|
+      Rbcli::Warehouse.set(key, default, namespace)
+      self.define_singleton_method(key) do |value|
+        Rbcli::Warehouse.set(key, value, namespace)
+      end
+    end
+  end
+
+  def self.opt * args
+    Rbcli::Parser.add_opt *args
+  end
+end