rbcli 0.3.2 → 0.4.0

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

@@ -0,0 +1,178 @@
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require_relative 'optimist/optimist'
+require 'stringio'
+module Rbcli::Parser
+  @parser = Optimist::Parser.new
+
+  def self.add_opt * args
+    Rbcli.log.debug "Set top-level opt argument: #{args}", "OPTS"
+    Rbcli::Warehouse.set(:opts, [], :unparsedopts) if Rbcli::Warehouse.get(:opts, :unparsedopts).nil?
+    Rbcli::Warehouse.get(:opts, :unparsedopts) << args
+  end
+
+  def self.parse
+    appinfo = Rbcli::Warehouse.get(nil, :appinfo) || {}
+    bannerstr = "#{appinfo[:appname] || EXECUTABLE}" + (appinfo[:version].nil? ? "\n" : " version: #{appinfo[:version]}\n")
+    unless appinfo[:copyright_year].nil? && appinfo[:author].nil?
+      bannerstr += "Copyright (C) #{appinfo[:copyright_year]} " unless appinfo[:copyright_year].nil?
+      bannerstr += "by #{appinfo[:author]}" if appinfo[:author].is_a? String
+      bannerstr += "by #{appinfo[:author].join(', ')}" if appinfo[:author].is_a? Array
+      bannerstr += " <#{appinfo[:email]}>" unless appinfo[:author].nil? || appinfo[:email].nil?
+      bannerstr += "\n"
+    end
+    bannerstr += "License: #{appinfo[:license]}\n" unless appinfo[:license].nil?
+    bannerstr += "\n"
+    bannerstr += appinfo[:helptext].chomp + "\n\n" unless appinfo[:helptext].nil?
+    bannerstr += "Usage:\n  #{EXECUTABLE} [options] command [parameters]\n\n"
+
+    non_default_commands = Rbcli::Warehouse.get(:commands).select { |_name, cmd| !cmd.default? }
+    if non_default_commands.count > 0
+      bannerstr += "For more information on individual commands, run `#{EXECUTABLE} <command> -h`\n\n"
+      bannerstr += "Commands:\n"
+      leftcol_width = non_default_commands.keys.map(&:length).max + 6
+      bannerstr += non_default_commands.map { |name, cmd| "  " + name + (" " * (leftcol_width - name.length)) + (cmd.description || '') }.join("\n")
+    end
+
+    @parser.synopsis bannerstr
+    (Rbcli::Warehouse.get(:opts, :unparsedopts) || []).each { |args| @parser.opt *args }
+    @parser.stop_on(non_default_commands.select { |_name, cmd| !cmd.default? }.keys)
+
+    begin
+      opts = @parser.parse
+      Rbcli::Warehouse.set(:opts, opts, :parsedopts)
+      Rbcli.log.debug "Found options: #{opts}", "OPTS"
+    rescue Optimist::CommandlineError => e
+      Rbcli.log.fatal e.message
+      Rbcli.log.fatal "Run `#{EXECUTABLE} -h` for more information"
+      Rbcli::exit 1
+    rescue Optimist::HelpNeeded
+      stream = StringIO.new
+      @parser.educate(stream)
+      Rbcli.log.info stream.string, "OPTS"
+      Rbcli::exit 0
+    rescue Optimist::VersionNeeded
+      Rbcli.log.info bannerstr.lines.first.chomp, "OPTS"
+      Rbcli::exit 0
+    end
+  end
+
+  def self.parse_command
+    cmd = { name: nil, command: nil, params: {}, args: [] }
+    cmd[:name] = !ARGV.first.nil? && !ARGV.first.start_with?('-') ? ARGV.shift.downcase : nil
+    default_command = Rbcli::Warehouse.get(:commands).values.select { |c| c.default? }.first
+    if cmd[:name].nil? && default_command.nil?
+      # CLI: Not given, Default: Not Set -- Educate
+      Rbcli.log.debug "Command not given, and no default command set. Displaying help.", "OPTS"
+      stream = StringIO.new
+      @parser.educate(stream)
+      Rbcli.log.info stream.string, "OPTS"
+      Rbcli::exit 0
+    elsif cmd[:name].nil?
+      # CLI: Not given, Default: Set -- Use Default
+      cmd[:command] = default_command
+      Rbcli.log.debug "Using default command: '#{cmd[:command].name}'", "OPTS"
+    elsif Rbcli::Warehouse.get(:commands).key?(cmd[:name])
+      # CLI: Given, Default: Not Set, Command: Found -- Use Command
+      cmd[:command] = Rbcli::Warehouse.get(:commands)[cmd[:name]]
+      Rbcli.log.debug "Using command: '#{cmd[:command].name}'", "OPTS"
+    elsif !default_command.nil?
+      # CLI: Given, Default: Set, Command: Not Found -- Pass it as an argument
+      cmd[:args] << cmd[:name]
+      while !ARGV.first.nil? && !ARGV.first.start_with?('-')
+        cmd[:args] << ARGV.shift
+      end
+      cmd[:command] = default_command
+      Rbcli.log.debug "Using default command: '#{cmd[:command].name}' with args: #{cmd[:args]}", "OPTS"
+    else
+      # CLI: Given, Default: Not Set, Command: Not Found -- Fail
+      Rbcli.log.fatal "Unknown command: '#{cmd[:name]}'", "OPTS"
+      Rbcli.log.fatal "Run `#{EXECUTABLE} -h` for more information", "OPTS"
+      Rbcli::exit 1
+    end
+    Rbcli::Warehouse.set(:command, cmd[:command], :parsedopts)
+
+    parser = Optimist::Parser.new
+
+    # We set the educate text
+    appinfo = Rbcli::Warehouse.get(nil, :appinfo) || {}
+    bannerstr = "#{appinfo[:appname] || EXECUTABLE}" + (appinfo[:version].nil? ? "\n" : " version: #{appinfo[:version]}\n")
+    bannerstr += "\n"
+    bannerstr += "Command: #{cmd[:command].name}\n\n"
+    bannerstr += cmd[:command].helptext.chomp + "\n\n" unless cmd[:command].helptext.nil?
+    bannerstr += "Usage:\n  #{EXECUTABLE} #{cmd[:command].name} #{cmd[:command].usage.chomp}" unless cmd[:command].usage.nil?
+    parser.synopsis(bannerstr)
+
+    # Then we add the options from the command
+    cmd[:command].params.each { |param| parser.opt *param }
+
+    begin
+      cmd[:params] = parser.parse
+      Rbcli::Warehouse.set(:params, cmd[:params], :parsedopts)
+      Rbcli.log.debug "Found parameters for command '#{cmd[:command].name}': #{cmd[:params]}", "OPTS"
+    rescue Optimist::CommandlineError => e
+      Rbcli.log.fatal e.message
+      Rbcli.log.fatal "Run `#{EXECUTABLE} #{cmd[:command].name} -h` for more information", "OPTS"
+      Rbcli::exit 1
+    rescue Optimist::HelpNeeded
+      stream = StringIO.new
+      parser.educate(stream)
+      Rbcli.log.info stream.string, "OPTS"
+      Rbcli::exit 0
+    end
+
+    cmd[:args].concat(ARGV)
+    Rbcli::Warehouse.set(:args, cmd[:args], :parsedopts)
+    ARGV.clear
+  end
+
+  def self.prompt_for_missing
+    Rbcli::Warehouse.get(:command, :parsedopts).params
+                    .select { |args| !args[2].nil? && !args[2].empty? && args[2][:prompt].is_a?(String) }
+                    .reject { |args| Rbcli::Warehouse.get(:params, :parsedopts).key?((args[0].to_s + '_given').to_sym) }
+                    .map { |args| { name: args[0].to_sym, prompt: args[2][:prompt], default: args[2][:default], type: args[2][:type].nil? ? nil : args[2][:type].to_s.chomp('s').to_sym } }
+                    .each do |opt|
+      prompt_string = opt[:prompt].strip
+      param_value = Rbcli::Warehouse.get(:params, :parsedopts)[opt[:name]]
+      if param_value.is_a?(TrueClass) || param_value.is_a?(FalseClass)
+        prompt_string += ' (' + (param_value ? 'Y' : 'y') + '/' + (param_value ? 'n' : 'N') + ')'
+        opt[:default] = param_value if opt[:default].nil?
+      elsif !opt[:default].nil?
+        prompt_string != " (default: #{opt[:default]})"
+      end
+      prompt_string += ':' unless %w(. ? ! :).include?(opt[:prompt][-1])
+      prompt_string += ' '
+
+      answer = nil
+      while answer.nil?
+        Rbcli.log.info prompt_string, "OPTS"
+        answer = gets.chomp
+        if [nil, :flag, :bool, :boolean, :trueclass, :falseclass].include?(opt[:type])
+          answer = { 'y' => true, 'n' => false, '' => opt[:default] }[(answer[0] || '').downcase]
+          next
+        end
+        if answer == ''
+          Rbcli.log.debug "Using default value of #{opt[:default]} for --#{opt[:name].to_s}", "OPTS"
+          answer = opt[:default]
+        end
+        begin
+          parser = Optimist::Parser.new
+          parser.opt(opt[:name], '', type: opt[:type])
+          newopts = parser.parse ["--#{opt[:name].to_s}", answer]
+        rescue Optimist::CommandlineError, Optimist::HelpNeeded, Optimist::VersionNeeded
+          Rbcli.log.debug "Invalid answer for type #{opt[:type]}", "OPTS"
+          answer = nil
+        else
+          answer = newopts[opt[:name]]
+        end
+      end
+      Rbcli::Warehouse.get(:params, :parsedopts)[opt[:name]] = answer
+    end
+  end
+
+  Rbcli::Engine.register_operation self.method(:parse), name: :cliopts_top_parse, priority: 10
+  Rbcli::Engine.register_operation self.method(:parse_command), name: :cliopts_command_parse, priority: 20
+  Rbcli::Engine.register_operation self.method(:prompt_for_missing), name: :cliopts_prompts, priority: 30
+end

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

@@ -0,0 +1,35 @@
+Rbcli::Configurate.cli do
+  <%- if @showdocs -%>
+  ##### Core Configuration (Required) #####
+  # appname          (Optional) - Defaults to the name of the executable
+  # author           (Optional) - A name or array of names
+  # email            (Optional) - An email for users to contact
+  # version          (Optional) - major.minor.patch notation, required if using update checks
+  # copyright_year   (Optional) - Self explanatory
+  # license          (Optional) - Convention is to use an identifier from here: https://spdx.org/licenses/
+  # helptext         (Optional) - Text that gets shown with --help or -h
+  <%- end -%>
+  appname nil
+  author nil
+  email nil
+  version <%= @appname.capitalize %>::VERSION
+  copyright_year <%= Time.now.year %>
+  license nil
+  helptext "This text shows up in `<%= @appname.downcase %> --help`"
+  <%- if @showdocs -%>
+  ##### CLI Options (Optional) #####
+  # These appear to commands as `opts`.
+  # Format:
+  #   opt :name, "Description"[, optional arguments ]
+  # Optional Arguments:
+  #   long: Specify the long form (--long) version of an argument. (Default: same as the name)
+  #   short: Specify the short form (-s) version of an argument. (Default: first letter of the name)
+  #   type: Specify the type. Valid options are :boolean, :float, :integer, :string, :io, :date. (Default: :boolean)
+  #     If the plural form of any of the above are used (i.e. ':strings') then the user can provide a comma-delimited list on the command line (--param=foo,bar)
+  #   required: If set to true, requires that this option is provided by the user. (Default: false)
+  #   multi: If set to true, allows the option to be provided multiple times (--param --param, or in short form, -pp). (Default: false)
+  #     When using this with a :boolean type, rather than returning `true` or `false`, it will return a count of the number of times the parameter was passed.
+  #   permitted: If set to an array, restricts input to the values within that array. (Default: nil (no restrictions))
+  <%- end -%>
+  opt :verbose, "Twice or more enables very-verbose output", multi: true
+end

data/lib/rbcli/components/updatechecker/common/common.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+# TODO: Detect invalid network connections and skip
+# TODO: Add a timeout
+require 'rubygems'
+module Rbcli::UpdateChecker
+  module Common
+    def check_for_updates
+      show_message if update_available?
+    end
+
+    private
+
+    def update_available?
+      Rbcli.log.debug "Checking for updates", "UPDT"
+      @latest_version = get_latest_version
+      unless @latest_version.nil?
+        begin
+          update_needed = Gem::Version.new(@latest_version) > Gem::Version.new(Rbcli::Warehouse.get(:version, :appinfo))
+        rescue ArgumentError => e
+          Rbcli.log.warn "Update check failed: #{e.message}"
+          false
+        else
+          Rbcli.log.debug "Latest version: #{@latest_version}", "UPDT"
+          Rbcli.log.debug "Current version: #{Rbcli::Warehouse.get(:version, :appinfo)}", "UPDT"
+          Rbcli.log.debug "Update not required", "UPDT" unless update_needed
+          update_needed
+        end
+      end
+    end
+
+    def show_message
+      Rbcli.log.warn "An update is available to #{Rbcli::Warehouse.get(:appname, :appinfo)} (#{Rbcli::Warehouse.get(:version, :appinfo)} -> #{@latest_version || get_latest_version})"
+      Rbcli.log.warn @message || update_message
+      if @force_update
+        Rbcli.log.error "This application requires that you update to the latest version to continue using it. It will now exit."
+        Rbcli::exit 25
+      end
+    end
+
+    def get_latest_version
+      raise Rbcli::Error.new "Update Checker type #{self.class.name} must define a 'check_for_updates' method."
+    end
+
+    def update_message
+      raise Rbcli::Error.new "Update Checker type #{self.class.name} must define an 'update_message' method."
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'rubygems'
+
+module Rbcli::Configurate::UpdateChecker
+  include Rbcli::Configurable
+
+  def self.gem gem, force_update: false, message: nil
+    raise Rbcli::ConfigurateError.new "Only one update checker can be specified" if Rbcli::Warehouse.get(:updatecheck)
+    raise Rbcli::ConfigurateError.new "Gem name provided for update checker is not valid" if gem.nil? || !gem.is_a?(String) || gem.empty?
+    raise Rbcli::ConfigurateError.new "Force_update must be a boolean value" unless force_update.is_a?(TrueClass) || force_update.is_a?(FalseClass)
+    raise Rbcli::ConfigurateError.new "Version string must be set in Rbcli::Configurate.cli to configure update checks" if Rbcli::Warehouse.get(:version, :appinfo).nil?
+    begin
+      Gem::Version.new(Rbcli::Warehouse.get(:version, :appinfo))
+    rescue ArgumentError => e
+      raise Rbcli::ConfigurateError.new e.message
+    end
+    require File.join(RBCLI_LIBDIR, 'components', 'updatechecker', 'gem_checker')
+    Rbcli::Warehouse.set(:updatecheck, Rbcli::UpdateChecker::GemChecker.new(gem, force_update, message))
+    Rbcli::Engine.register_operation Rbcli::Warehouse.get(:updatecheck).method(:check_for_updates), name: :updatechecke_by_gem, priority: 60
+    Rbcli.log.debug "Registered update checker by gem for gem: #{gem}", "UPDT"
+  end
+
+  def self.github github_repo, access_token: nil, enterprise_hostname: nil, force_update: false, message: nil
+    raise Rbcli::ConfigurateError.new "Only one update checker can be specified" if Rbcli::Warehouse.get(:updatecheck)
+    raise Rbcli::ConfigurateError.new "Repo name provided for update checker is not valid" if github_repo.nil? || !github_repo.is_a?(String) || github_repo.empty?
+    raise Rbcli::ConfigurateError.new "Force_update must be a boolean value" unless force_update.is_a?(TrueClass) || force_update.is_a?(FalseClass)
+    raise Rbcli::ConfigurateError.new "Version string must be set in Rbcli::Configurate.cli to configure update checks" if Rbcli::Warehouse.get(:version, :appinfo).nil?
+    begin
+      Gem::Version.new(Rbcli::Warehouse.get(:version, :appinfo))
+    rescue ArgumentError => e
+      raise Rbcli::ConfigurateError.new e.message
+    end
+    require File.join(RBCLI_LIBDIR, 'components', 'updatechecker', 'github_checker')
+    Rbcli::Warehouse.set(:updatecheck, Rbcli::UpdateChecker::GithubChecker.new(github_repo, access_token, enterprise_hostname, force_update, message))
+    Rbcli::Engine.register_operation Rbcli::Warehouse.get(:updatecheck).method(:check_for_updates), name: :updatechecke_by_github, priority: 60
+    Rbcli.log.debug "Registered update checker by github repo for github_repo: #{github_repo}", "UPDT"
+  end
+end

data/lib/rbcli/components/updatechecker/gem_checker.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require_relative 'common/common'
+require 'rest-client'
+require 'json'
+
+module Rbcli::UpdateChecker
+  class GemChecker
+    include Common
+
+    def initialize gemname, force_update, message
+      @gemname = gemname
+      @url = "https://rubygems.org/api/v1/versions/#{gemname}/latest.json"
+      @force_update = force_update
+      @message = message
+    end
+
+    private
+
+    def get_latest_version
+      begin
+        response = RestClient::Request.execute(method: :get, url: @url, timeout: 1)
+        JSON.parse(response.body)['version']
+      rescue SocketError => e
+        Rbcli.log.debug ["Connection error when getting latest gem version", "#{e.message}", "Failing update check silently."].join("\n"), "UPDT"
+        nil
+      rescue Net::OpenTimeout => _e
+        Rbcli.log.debug "Autoupdate check failed - timeout while connecting to RubyGems API. Failing silently."
+        nil
+      end
+    end
+
+    def update_message
+      "Please run `gem update #{@gemname}` to upgrade to the latest version. You can preview it at: https://rubygems.org/gems/#{@gemname}/versions/#{@latest_version}"
+    end
+  end
+end

data/lib/rbcli/components/updatechecker/github_checker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require_relative 'common/common'
+require 'octokit'
+
+module Rbcli::UpdateChecker
+  class GithubChecker
+    include Common
+
+    def initialize reponame, access_token, enterprise_hostname, force_update, message
+      @reponame = reponame
+      @force_update = force_update
+      @message = message
+      @hostname = enterprise_hostname || "github.com"
+
+      Octokit.configure { |c| c.api_endpoint = "https://#{enterprise_hostname}/api/v3/" } if enterprise_hostname
+
+      #@client = Octokit::Client.new :client_id => client_id, :client_secret => client_secret
+      @client = Octokit::Client.new(access_token: access_token)
+    end
+
+    private
+
+    def get_latest_version
+      begin
+        @client.repo(@reponame).rels[:tags].get.data.map { |t| t[:name] }[0].sub(/^[v]*/, "")
+      rescue Faraday::ConnectionFailed => e
+        Rbcli.log.debug ["Connection error when getting latest version from github", "#{e.message}", "Failing update check silently"].join("\n"), "UPDT"
+        nil
+      rescue Octokit::TooManyRequests => e
+        Rbcli.log.debug ["Reached GitHub rate limit; too many requests", "#{e.message}", "Failing update check silently"].join("\n"), "UPDT"
+        nil
+      rescue NoMethodError => e
+        Rbcli.log.debug ["Repo was found but could not find the version tag", "#{e.message}", "Failing update check silently"].join("\n"), "UPDT"
+        nil
+      end
+    end
+
+    def update_message
+      "Please check the github repo https://#{@hostname}/#{@reponame} for instructions on how to update to the latest version"
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+Rbcli::Configurate.updatechecker do
+  <%- if @showdocs -%>
+  ##### Update Check (Optional) #####
+  # The application can warn users when a new version is released
+  # Checks can be done either by rubygems or by a Github repo
+  # Private servers for Github (enterprise) are supported
+  #
+  # Setting force_update to true will halt execution until it is updated
+  #
+  # For Github, an access_token is required for private repos. See: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens
+  <%- end -%>
+  # gem '<%= @appname.downcase %>', force_update: false, message: 'Please run `gem update <%= @appname.downcase %>` to upgrade to the latest version.'
+  # github 'repo/name', access_token: nil, enterprise_hostname: nil, force_update: false, message: 'Please download the latest version from Github'
+end

data/lib/rbcli/util/deprecation_warning.rb

@@ -1,60 +1,46 @@
+# frozen_string_literal: true
 ##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program 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.                                        #
-#                                                                                #
-#     This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
 ##################################################################################
-
+require 'rubygems'
 
 class Rbcli::DeprecationWarning
-
-	@@warnings = []
-	@@errors_exist = false
-
-	def initialize original_feature_name, message_text, change_by_version, caller
-		#@caller = caller_locations(2,1)[0].label
-		@original_feature_name = original_feature_name
-		@message_text = message_text
-		@change_by_version = change_by_version
-		@caller = caller
-		@@warnings.append self
-	end
-
-	def display
-		deprecated_version_parts = @change_by_version.split('.').map { |i| i.to_i }
-		current_version_parts = Rbcli::VERSION.split('.').map { |i| i.to_i }
-
-		if deprecated_version_parts[0] > current_version_parts[0] or
-				deprecated_version_parts[1] > current_version_parts[1] or
-				deprecated_version_parts[2] >= current_version_parts[2]
-
-			message = "DEPRECATION ERROR: The feature `#{@original_feature_name}` has been deprecated as of Rbcli version #{@change_by_version}. #{@message_text} Please update the relevant code to continue using Rbcli."
-			Rbcli::log.error { message }
-			puts message.red
-			@@errors_exist = true
-		else
-			message = "DEPRECATION WARNING: The feature `#{@original_feature_name}` has been deprecated. #{@message_text} This feature will be removed in version #{@change_by_version}."
-			Rbcli::log.warn { message }
-			puts message.yellow
-		end
-		puts @caller[0], ""
-	end
-
-	def self.display_warnings
-		@@warnings.each { |w| w.display }
-		exit(1) if @@errors_exist
-	end
+  def initialize offending_object, warn_at: nil, deprecate_at: nil, message: nil
+    if offending_object.is_a?(String)
+      @offender = offending_object
+      @in_rbcli = offending_object.include?('Rbcli')
+    else
+      @offender = (offending_object.respond_to?(:name) && offending_object.name.include?('::')) ? @offender = offending_object.name : @offender = offending_object.class.name
+      @in_rbcli = offending_object.name.include?('Rbcli')
+    end
+    # @method = self.caller_locations[1].label
+    @message = message
+
+    raise Rbcli::ConfigurateError.new "The `warn_at` and `deprecate_at` values must both be set" if warn_at.nil? || deprecate_at.nil?
+    raise Rbcli::ConfigurateError.new "Version string must be set in Rbcli::Configurate.cli to use deprecation warnings" if !@in_rbcli && Rbcli::Warehouse.get(:version, :appinfo).nil?
+    @current_version = @in_rbcli ? Rbcli::VERSION : Gem::Version.new(Rbcli::Warehouse.get(:version, :appinfo))
+    @warning_version = Gem::Version.new(warn_at)
+    @error_version = Gem::Version.new(deprecate_at)
+    raise Rbcli::ConfigurateError.new "Warning version must come earlier than the deprecation version" if @warning_version >= @error_version
+
+    @callerstack = self.caller_locations
+    self.parse
+  end
+
+  private
+
+  def parse
+    if @current_version >= @error_version
+      Rbcli.log.error [
+                        "DEPRECATION ERROR -- #{@offender.to_s}".red.bold + " -- The removal of this method is imminent. Please update your application accordingly.".red,
+                        @message.nil? ? nil : @message.red
+                      ].reject(&:nil?).map { |str| "DEPR".red + ' || ' + str }.join("\n"), "DEPR"
+    elsif @current_version >= @warning_version
+      Rbcli.log.warn [
+                       "DEPRECATION WARNING -- #{@offender.to_s.yellow.bold}" + " -- This method is scheduled to be removed on version #{@error_version}. You are on version #{@current_version}.".yellow,
+                       @message.nil? ? nil : @message.yellow
+                     ].reject(&:nil?).map { |str| "DEPR".yellow + ' || ' + str }.join("\n"), "DEPR"
+    end
+  end
 end

data/lib/rbcli/util/errors.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>                        #
+##################################################################################
+module Rbcli
+  class Error < StandardError; end
+
+  class ConfigurateError < Rbcli::Error; end
+
+  class CommandError < Rbcli::Error; end
+end

data/lib/rbcli/util/exit.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>                        #
+##################################################################################
+module Rbcli
+  @real_exit = method(:exit)
+
+  def self.exit code
+    @real_exit.call(code)
+  end
+end

data/lib/rbcli/util/hash_deep_symbolize.rb

@@ -1,49 +1,34 @@
+# frozen_string_literal: true
 ##################################################################################
-#     RBCli -- A framework for developing command line applications in Ruby      #
-#     Copyright (C) 2018 Andrew Khoury                                           #
-#                                                                                #
-#     This program 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.                                        #
-#                                                                                #
-#     This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.     #
-#                                                                                #
-#     For questions regarding licensing, please contact andrew@blacknex.us       #
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
 ##################################################################################
 
-
 ##
 # Functions to convert hash keys to all symbols or all strings
 ##
 class Hash
-	def deep_symbolize! hsh = nil
-		hsh ||= self
-		hsh.keys.each do |k|
-			if k.is_a? String
-				hsh[k.to_sym] = hsh[k]
-				hsh.delete k
-			end
-			deep_symbolize! hsh[k.to_sym] if hsh[k.to_sym].is_a? Hash
-		end
-		hsh
-	end
+  def deep_symbolize! hsh = nil
+    hsh ||= self
+    hsh.keys.each do |k|
+      if k.is_a? String
+        hsh[k.to_sym] = hsh[k]
+        hsh.delete k
+      end
+      deep_symbolize! hsh[k.to_sym] if hsh[k.to_sym].is_a? Hash
+    end
+    hsh
+  end
 
-	def deep_stringify! hsh = nil
-		hsh ||= self
-		hsh.keys.each do |k|
-			if k.is_a? Symbol
-				hsh[k.to_s] = hsh[k]
-				hsh.delete k
-			end
-			deep_stringify! hsh[k.to_s] if hsh[k.to_s].is_a? Hash
-		end
-		hsh
-	end
-end
+  def deep_stringify! hsh = nil
+    hsh ||= self
+    hsh.keys.each do |k|
+      if k.is_a? Symbol
+        hsh[k.to_s] = hsh[k]
+        hsh.delete k
+      end
+      deep_stringify! hsh[k.to_s] if hsh[k.to_s].is_a? Hash
+    end
+    hsh
+  end
+end

data/lib/rbcli/util/string_compression.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'base64'
+require 'zlib'
+
+String.instance_eval { define_method(:compress) { Base64.encode64(Zlib::Deflate.deflate(self)).chomp } }
+String.instance_eval { define_method(:decompress) { Zlib::Inflate.inflate(Base64.decode64(self)) } }