rbcli 0.3.3 → 0.4.1

data/lib/rbcli/components/config/backends/toml.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'toml'
+
+class Rbcli::UserConf::Toml < Rbcli::UserConf::Backend
+  private
+
+  def parse str
+    begin
+      parsed_str = TOML.load(str).deep_symbolize!
+    rescue => e
+      Rbcli.log.warn "Error when parsing TOML file", "CONF"
+      Rbcli.log.warn e.message, "CONF"
+      Hash.new
+    else
+      @loaded = true
+      parsed_str
+    end
+  end
+
+  def unparse hash
+    TOML::Generator.new(hash).body
+  end
+
+  def inject_banner text, banner
+    banner.lines.map { |line| "# #{line.chomp}" }.join("\n") + "\n" + text
+  end
+end
+
+class Symbol
+  def to_toml(path = "")
+    '"' + self.to_s.sub(/^:/, '') + '"'
+  end
+end

data/lib/rbcli/components/config/backends/yaml.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'yaml'
+
+class Rbcli::UserConf::Yaml < Rbcli::UserConf::Backend
+  private
+
+  def parse str
+    begin
+      parsed_str = YAML.safe_load(str, symbolize_names: true, aliases: true, permitted_classes: [Symbol])
+    rescue Psych::SyntaxError, Psych::DisallowedClass => e
+      Rbcli.log.warn "Invalid #{@type} syntax found at '#{@path}'", "CONF"
+      Rbcli.log.warn e.message, "CONF"
+      Hash.new
+    else
+      @loaded = true
+      parsed_str
+    end
+  end
+
+  def unparse hash
+    hash.to_yaml
+  end
+
+  def inject_banner text, banner
+    banner.lines.map { |line| "# #{line.chomp}" }.join("\n") + "\n" + text
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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::Config
+  include Rbcli::Configurable
+
+  def self.file location: nil, type: nil, schema_location: nil, save_on_exit: false, create_if_not_exists: false, suppress_errors: false
+    raise Rbcli::ConfigurateError.new "Config file location must either be a path or an array of paths" unless location.nil? || location.is_a?(String) || (location.is_a?(Array) && location.all? { |loc| loc.is_a?(String) })
+    raise Rbcli::ConfigurateError.new "Config schema file location must be a path" unless schema_location.nil? || schema_location.is_a?(String)
+    raise Rbcli::ConfigurateError.new "Config type must be one of the following: #{Rbcli::UserConf::Backend.types.keys.join(', ')}" unless (type.is_a?(String) || type.is_a?(Symbol)) && Rbcli::UserConf::Backend.types.key?(type.downcase.to_sym)
+    config = Rbcli::Config.new location: location, type: type, schema_location: schema_location, create_if_not_exists: create_if_not_exists, suppress_errors: suppress_errors
+    Rbcli::Warehouse.set(:config, config, :parsedopts)
+    Rbcli::Engine.register_operation Proc.new { Rbcli::Warehouse.get(:config, :parsedopts).load!; Rbcli::Warehouse.get(:config, :parsedopts).validate! }, name: :load_config, priority: 40
+    Rbcli::Engine.register_operation Proc.new { Rbcli::Warehouse.get(:config, :parsedopts).save! }, name: :save_config, priority: 160 if save_on_exit
+  end
+
+  def self.banner text
+    raise Rbcli::ConfigurateError.new "The banner must be set to a string." unless text.is_a?(String)
+    Rbcli::Warehouse.get(:config, :parsedopts).set_banner text
+  end
+
+  def self.defaults hash
+    raise Rbcli::ConfigurateError.new "The default configuration must be a hash." unless hash.is_a?(Hash)
+    Rbcli::Warehouse.get(:config, :parsedopts).defaults = hash
+  end
+end

data/lib/rbcli/components/config/config.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'deep_merge'
+require 'json-schema'
+require_relative 'backend'
+
+class Rbcli::Config < Hash
+  def initialize location: nil, type: nil, schema_location: nil, create_if_not_exists: false, suppress_errors: false
+    location = [location] unless location.is_a?(Array)
+    locations = location.map { |path| [path, Rbcli::UserConf::Backend.create(path, type: type)] }.reject { |path, storage| !(path.nil? || path == :null) && storage.type == 'NULL' }
+    existing_location = locations.select { |_path, storage| storage.exist? }.first
+    savable_location = locations.select { |_path, storage| storage.savable? }.first
+    if !existing_location.nil?
+      @location, @storage = existing_location
+      Rbcli.log.debug @location.nil? ? "Instantiated null config; data will not be stored" : "Found config of type '#{@storage.type}' at '#{@location}'", "CONF"
+    elsif !savable_location.nil? && create_if_not_exists
+      @location, @storage = savable_location
+      @should_create = true
+      Rbcli.log.debug "Ready to create new config of type '#{@storage.type}' at '#{@location}'", "CONF"
+    elsif suppress_errors
+      @location, @storage = :null, Rbcli::UserConf::Backend.create(:null)
+      Rbcli.log.debug "Location(s) could not be found and/or are not writeable. Instantiating null config and failing silently.", "CONF"
+    else
+      Rbcli.log.fatal "Config file could not be loaded. Please verify that it exists at one of the following locations: #{location.join(", ")}", "CONF"
+      Rbcli::exit 2
+    end
+    @suppress_errors = suppress_errors
+    @original_hash = {}
+    @defaults = {}
+    if schema_location
+      @schema = self.class.new(location: schema_location)
+      @schema.is_schema = true
+    end
+  end
+
+  attr_accessor :is_schema, :defaults
+
+  def set_banner text
+    @banner = text
+  end
+
+  def add_default slug, default: nil
+    @defaults[slug] = default
+  end
+
+  def type
+    @storage.type.downcase.to_sym
+  end
+
+  def load!
+    if @should_create
+      Rbcli.log.add (@suppress_errors ? :debug : :info), "Config file #{@location} does not exist. Creating with default values.", "CONF"
+      self.deep_merge!(@storage.respond_to?(:parse_defaults) ? @storage.parse_defaults(@defaults) : @defaults)
+      self.save!
+    else
+      Rbcli.log.debug "Loading #{@is_schema ? 'schema' : 'config'} file", "CONF"
+      @original_hash = @storage.load(defaults: @defaults)
+      if !@storage.loaded?
+        Rbcli.log.add (@suppress_errors ? :debug : :warn), "Could not load #{@is_schema ? 'schema' : 'config'} file", "CONF"
+        Rbcli.log.add (@suppress_errors ? :debug : :warn), "Using defaults", "CONF" unless @defaults.empty?
+        return false
+      else
+        self.deep_merge!(@storage.respond_to?(:parse_defaults) ? @storage.parse_defaults(@defaults) : @defaults)
+        self.deep_merge!(@original_hash.deep_symbolize!) if @original_hash.is_a?(Hash)
+      end
+    end
+  end
+
+  def validate!
+    return true if @schema.nil?
+    Rbcli.log.debug "Validating config against schema", "CONF"
+    @schema.load!
+    begin
+      JSON::Validator.validate!(@schema, self)
+    rescue JSON::Schema::ValidationError => e
+      Rbcli.log.send (@suppress_errors ? :debug : :error), "There are errors in the config. Please fix these errors and try again."
+      Rbcli.log.send (@suppress_errors ? :debug : :error), JSON::Validator.fully_validate(@schema, self).join("\n")
+      Rbcli::exit 3 unless @suppress_errors
+      return false
+    end
+    Rbcli.log.debug "Validated config against schema successfully", "CONF"
+    true
+  end
+
+  def save!
+    unless @storage.savable?
+      Rbcli.log.add (@suppress_errors ? :debug : :warn), "Config file not savable. Data not stored.", "CONF"
+      return false
+    end
+    hash_to_save = Marshal.load(Marshal.dump(self)).to_h # This removes all custom instance variables and types from the data
+    if hash_to_save == @original_hash && !@should_create
+      Rbcli.log.debug "No changes detected in the config. Skipping save.", "CONF"
+    else
+      Rbcli.log.debug "Changes detected in the config. Saving updated config.", "CONF"
+      @storage.save(hash_to_save.deep_stringify!)
+      @original_hash = hash_to_save.deep_symbolize!
+      @should_create = false
+    end
+    self
+  end
+
+  def annotate!
+    @storage.annotate! @banner
+  end
+end
+
+require_relative 'config_of_death'

data/lib/rbcli/components/config/config_of_death.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+class Rbcli::ConfigOfDeath < Rbcli::Config
+  (Rbcli::Config.instance_methods - Class.instance_methods).each do |method|
+    self.define_method(method) do |*args|
+      raise Rbcli::ConfigurateError.new "Attempted to access config that was not configured."
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+Rbcli::Configurate.config do
+  <%- if @showdocs -%>
+  ##### Config (Optional) #####
+  # The built-in config will automatically pull in a config file to a hash and vice versa
+  # It can either be used immutably (as user-defined configuration) and/or to store application state
+  #
+  # file location:             <string> or <array>            (Required) Provide either a specific config file location or a hierarchy to search
+  #      type:                 (:yaml|:json|:ini|:toml|:null) (Optional) Select which backend/file format to use. If the file has an associated extension (i.e. '.yaml') then this can be omitted.
+  #      schema_location:      <string>                       (Optional) The file location of a JSON Schema (https://json-schema.org). If provided, the config will automatically be validated. (default: nil)
+  #      save_on_exit:         (true|false)                   (Optional) Save changes to the config file on exit (default: false)
+  #      create_if_not_exists: (true|false)                   (Optional) Create the file using default values if it is not found on the system (default: false)
+  #      suppress_errors:      (true|false)                   (Optional) If set to false, the application will halt on any errors in loading the config. If set to true, defaults will be provided (default: true)
+  <%- end -%>
+  file location: ['./<%= @appname.downcase %>.yaml', '~/.<%= @appname.downcase %>.yaml', '/etc/<%= @appname.downcase %>.yaml'],
+       type: :yaml, schema_location: nil, save_on_exit: false,
+       create_if_not_exists: false, suppress_errors: true
+  <%- if @showdocs -%>
+  ##### Banner (Optional) #####
+  # Define a banner to be placed at the top of the config file.
+  # Note that the banner will only be written to backends that support comments (:yaml, :ini, and :toml).
+  <%- end -%>
+  banner <<~BANNER
+    This text appears at the top of the config file when using a backend that supports comments.
+    Tell the user a bit about what they're doing here.
+  BANNER
+  <%- if @showdocs -%>
+  ##### Defaults (Optional) #####
+  # Set defaults for your config values.
+  #
+  # Defaults set here will be provided to your application if the values are missing in the config.
+  # They will also be used to create new config files when the flag `create_if_not_exists` is set to true.
+  <%- end -%>
+  defaults({ setting_one: true, setting_two: false })
+end

data/lib/rbcli/components/core/configurate.rb

@@ -0,0 +1,63 @@
+# 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
+  # If a non-existant method is called, we attempt to load the plugin.
+  # If the plugin fails to load we display a message to the developer
+  def self.method_missing(method, *args, &block)
+    filename = File.join(RBCLI_LIBDIR, 'plugins', method.to_s.downcase, 'component.rb')
+    if File.exist? filename
+      require filename
+      self.send method, *args, &block
+    else
+      raise Rbcli::ConfigurateError.new "Invalid Rbcli Configurate plugin called: `#{method}` in file #{File.expand_path caller[0]}"
+    end
+  end
+end
+
+module Rbcli::Configurable
+  def self.included klass
+    # We dynamically add two methods to the module: one that runs other methods dynamially, and one that
+    # displays a reasonable message if a method is missing
+    klass.singleton_class.class_eval do
+      define_method :rbcli_private_running_method do |&block|
+        @self_before_instance_eval = eval 'self', block.binding
+        instance_eval &block
+      end
+
+      define_method :method_missing do |method, *args, &block|
+        raise Rbcli::ConfigurateError.new "Invalid Configurate.#{self.name.split('::')[-1].downcase} method called: `#{method}` in file #{File.expand_path caller[0]}"
+      end
+    end
+
+    # This will dynamically create the configurate block based on the class name.
+    # For example, if the class name is 'Me', then the resulting block is `Configurate.me`
+    name = klass.name.split('::')[-1]
+    Rbcli::Configurate.singleton_class.class_eval do
+      define_method name.downcase.to_sym do |&block|
+        mod = self.const_get name
+        begin
+          mod.rbcli_private_running_method &block
+        rescue Rbcli::ConfigurateError => e
+          Rbcli.log.fatal 'Rbcli Configuration Error: ' + e.message
+          Rbcli::exit 255
+        end
+      end
+    end
+  end
+end
+
+Dir.glob(File.dirname(__FILE__) + '/../**/component.rb', &method(:require))
+
+# module Rbcli
+#   def self.configuration mod, key = nil
+#     begin
+#       d = Rbcli::Configurate.const_get(mod.to_s.capitalize.to_sym).config
+#       (key.nil?) ? d : d[key]
+#     rescue
+#       nil
+#     end
+#   end
+# end

data/lib/rbcli/components/core/engine.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+module Rbcli::Engine
+  @operations = []
+
+  def self.register_operation operation, name: nil, priority: nil
+    if @operations.select { |op| op[:priority] == priority }.count != 0
+      raise Rbcli::Error.new "The Rbcli engine can not have two operations defined with the same priority: #{name}, #{@operations.select { |op| op[:priority] == priority }.join(", ")}"
+    end
+    @operations << { operation: operation, name: name, priority: priority }
+  end
+
+  def self.run!
+    Rbcli.log.debug "The engine has been started", "ENGN"
+    @operations.sort_by { |op| op[:priority] }.each do |op|
+      Rbcli.log.debug "Running operation #{op[:priority]} -- #{op[:name]}", "ENGN"
+      op[:operation].call
+    end
+    Rbcli.log.debug "The engine has been stopped", "ENGN"
+  end
+end
+
+module Rbcli
+  def self.go!
+    Rbcli::Engine.run!
+  end
+end

data/lib/rbcli/components/core/warehouse.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+module Rbcli::Warehouse
+  @data = {}
+
+  def self.set key, value, namespace = :default
+    raise Rbcli::Error.new "Namespace must be a symbol" unless namespace.is_a? Symbol
+    @data[namespace] ||= {}
+    @data[namespace][key] = value
+  end
+
+  def self.get key, namespace = :default
+    key.nil? ? @data.dig(namespace) : @data.dig(namespace, key)
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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::Envvars
+  include Rbcli::Configurable
+
+  def self.prefix envvar_prefix
+    raise Rbcli::ConfigurateError.new "Environment variable prefix must be a string" unless envvar_prefix.is_a?(String)
+    env = Rbcli::Config.new location: envvar_prefix.sub(/_+$/, ''), type: :env
+    Rbcli::Warehouse.set(:env, env, :parsedopts)
+    Rbcli::Engine.register_operation Proc.new { Rbcli::Warehouse.get(:env, :parsedopts).load! }, name: :load_envvars, priority: 50
+  end
+
+  def self.envvar envvar, default
+    raise Rbcli::ConfigurateError.new "Environment variables must be a string" unless envvar.is_a?(String)
+    Rbcli::Warehouse.get(:env, :parsedopts).add_default(envvar, default: default)
+  end
+end

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

@@ -0,0 +1,24 @@
+Rbcli::Configurate.envvars do
+  <%- if @showdocs -%>
+  ##### Environment Variable Parsing (Optional) #####
+  # The envvars module can pull in all environment variables with a given
+  # prefix and organize them into a hash structure based on name.
+  # It will also parse the string values and convert them to the proper type (Integer, Boolean, etc)
+  # Any values set here will be treated as defaults and made available when a variable is missing
+  #
+  # For example, these two environment variables:
+  #   <%= @appname.upcase %>_TERM_HEIGHT=40
+  #   <%= @appname.upcase %>_TERM_WIDTH=120
+  # Would be declared here as:
+  #   prefix '<%= @appname.upcase %>'
+  #   envvar 'TERM_HEIGHT', 40
+  #   envvar 'TERM_WIDTH', 120
+  # And get loaded into the env hash as:
+  #   { term: { height: 40, width: 120 } }
+  #
+  # If the prefix is unset or equal to nil, the environment variables specified here will
+  # be loaded without one.
+  <%- end -%>
+  prefix '<%= @appname.upcase %>'
+  envvar 'DEVELOPMENT', false
+end

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

@@ -0,0 +1,36 @@
+# 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::Hooks
+  include Rbcli::Configurable
+
+  def self.pre_execute & block
+    Rbcli::Warehouse.set(:pre_execute, block, :hooks)
+    Rbcli.log.debug "Registered pre_execute hook", "HOOK"
+    Rbcli::Engine.register_operation(Proc.new do
+      Rbcli::Warehouse.get(:pre_execute, :hooks).call(
+        Rbcli::Warehouse.get(:opts, :parsedopts),
+        Rbcli::Warehouse.get(:params, :parsedopts),
+        Rbcli::Warehouse.get(:args, :parsedopts),
+        Rbcli::Warehouse.get(:config, :parsedopts) || Rbcli::ConfigOfDeath.new,
+        Rbcli::Warehouse.get(:env, :parsedopts) || Rbcli::ConfigOfDeath.new
+      )
+    end, name: :pre_execute_hook, priority: 90)
+  end
+
+  def self.post_execute & block
+    Rbcli::Warehouse.set(:post_execute, block, :hooks)
+    Rbcli.log.debug "Registered post_execute hook", "HOOK"
+    Rbcli::Engine.register_operation(Proc.new do
+      Rbcli::Warehouse.get(:post_execute, :hooks).call(
+        Rbcli::Warehouse.get(:opts, :parsedopts),
+        Rbcli::Warehouse.get(:params, :parsedopts),
+        Rbcli::Warehouse.get(:args, :parsedopts),
+        Rbcli::Warehouse.get(:config, :parsedopts) || Rbcli::ConfigOfDeath.new,
+        Rbcli::Warehouse.get(:env, :parsedopts) || Rbcli::ConfigOfDeath.new
+      )
+    end, name: :post_execute_hook, priority: 110)
+  end
+end

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

@@ -0,0 +1,20 @@
+Rbcli::Configurate.hooks do
+  <%- if @showdocs -%>
+  ##### Hooks (Optional) #####
+  # These hooks are scheduled on the Rbcli execution engine to run
+  # Pre- and Post- the command specified. They are executed after
+  # everything else has been initialized, so the runtime configuration
+  # values are all made available, as they will appear to the command.
+  #
+  # These are good for parsing and/or doing transformations on the provided
+  # configuration before passing them to the command, and for cleaning
+  # up your environment afterwards.
+  <%- end -%>
+  pre_execute do |opts, params, args, config, env|
+    Rbcli.log.info "I'm about to run a command..."
+  end
+
+  post_execute do |opts, params, args, config, env|
+    Rbcli.log.info "I'm done running the command!"
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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::Logger
+  include Rbcli::Configurable
+
+  def self.logger target: :stdout, level: :info, format: :display
+    unless target.is_a?(IO) ||
+      (defined?(StringIO) && target.is_a?(StringIO)) ||
+      (target.is_a?(String) && Dir.exist?(File.dirname(File.expand_path(target)))) ||
+      (target.is_a?(Symbol) && [:stdout, :stderr].include?(target.to_sym))
+      raise Rbcli::ConfigurateError.new "Log Target is invalid. Please use either :stdout, :stderr, or a valid file path where the directory already exists on the system. Target given: #{target}"
+    end
+    unless level.is_a?(Integer) || %i(debug info warn error fatal unknown).include?(level)
+      raise Rbcli::ConfigurateError.new "Log Level must be one of the following: #{%i(debug info warn error fatal unknown)}. Level provided: #{level}"
+    end
+    unless Rbcli::Logger.formats.include?(format)
+      raise Rbcli::ConfigurateError.new "Log format must be one of the following: #{Rbcli::Logger.formats}. Format provided: #{format}"
+    end
+    Rbcli.start_logger(target: target, level: level, format: format)
+    Rbcli.log.debug "Logger initialized with target #{target} at level #{level}", "CORE"
+  end
+
+  def self.format slug, prok
+    raise Rbcli::ConfigurateError.new "The slug for the custom log format must be a string or a symbol." unless slug.is_a?(String) || slug.is_a?(Symbol)
+    raise Rbcli::ConfigurateError.new "A proc must be provided to use a custom log format" unless prok.is_a?(Proc)
+    Rbcli.log.add_format slug, prok
+    Rbcli.log.format slug
+  end
+end

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