rbcli 0.3.2 → 0.4.0

data/lib/rbcli/components/commands/command_old.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+module Rbcli::Core::CmdLibrary
+  def self.extended klass
+    klass.instance_variable_set :@commands, {}
+  end
+
+  def inherited subklass
+    raise Rbcli::CommandError.new "The command #{subklass.name.downcase} cannot be defined twice." unless @commands[subklass.name.downcase].nil?
+    subklass.instance_variable_set :@data, {
+      description: nil,
+      helptext: nil,
+      default: nil,
+      action: nil,
+      script: nil,
+      usage: nil,
+      parameter_prompts: {},
+      parser: Optimist::Parser.new
+    }
+    @commands[subklass.name.downcase] = subklass.new
+    Rbcli::Cliopts.register_command subklass.name.downcase
+    Rbcli.log.debug "Registered command '#{subklass.name.downcase}'", "CORE"
+
+    Rbcli::Engine.register_operation Proc.new {
+      Rbcli.log.debug "Running command '#{Rbcli::Cliopts.cmd[:name]}'", "CORE"
+      Rbcli::Cliopts.cmd[:command].data[:action].call(Rbcli::Cliopts.opts,
+                                                      Rbcli::Cliopts.cmd[:params],
+                                                      Rbcli::Cliopts.cmd[:args],
+                                                      (Rbcli::Configurate.constants.include?(:Config) ? Rbcli.configuration(:config)[:config] : Rbcli::Config.new(suppress_errors: true)),
+                                                      (Rbcli::Configurate.constants.include?(:Envvars) ? Rbcli.configuration(:envvars)[:envvars] : Rbcli::Config.new(suppress_errors: true))
+      ) unless Rbcli::Cliopts.cmd[:command].data[:action].nil?
+      Rbcli::Cliopts.cmd[:command].data[:script].execute(Rbcli::Cliopts.opts,
+                                                         Rbcli::Cliopts.cmd[:params],
+                                                         Rbcli::Cliopts.cmd[:args],
+                                                         (Rbcli::Configurate.constants.include?(:Config) ? Rbcli.configuration(:config)[:config] : Rbcli::Config.new(suppress_errors: true)),
+                                                         (Rbcli::Configurate.constants.include?(:Envvars) ? Rbcli.configuration(:envvars)[:envvars] : Rbcli::Config.new(suppress_errors: true))
+      ) unless Rbcli::Cliopts.cmd[:command].data[:script].nil?
+    }, name: :run_command, priority: 100 if @commands.count == 1
+  end
+
+  def data
+    self.instance_variable_get :@data;
+  end
+
+  def commands
+    @commands.select { |name, cmd| !cmd.data[:default] }
+  end
+
+  def default_command
+    default_commands = @commands.select { |_name, cmd| cmd.data[:default] }
+    raise Rbcli::CommandError.new "Can't execute - more than one command has been specified as default: #{default_commands.keys}" if default_commands.count > 1
+    default_commands.count == 1 ? default_commands.first : nil
+  end
+end
+
+class Rbcli::Command
+  extend Rbcli::Core::CmdLibrary
+
+  def data
+    self.class.data
+  end
+
+  def self.description desc = nil
+    desc.nil? ? @data[:description] : @data[:description] = desc
+  end
+
+  def self.helptext text = nil
+    text.nil? ? @data[:helptext] : @data[:helptext] = text
+  end
+
+  def self.usage text = nil
+    text.nil? ? @data[:usage] : @data[:usage] = text
+  end
+
+  def self.default
+    @data[:default] = true
+  end
+
+  def self.parameter * args
+    if !args[2].nil? && !args[2].empty? && args[2][:prompt].is_a?(String)
+      @data[:parameter_prompts][args[0]] = { prompt: args[2][:prompt], default: args[2][:default], type: args[2][:type].nil? ? nil : args[2][:type].to_s.chomp('s').to_sym }
+      args[2][:required] = false
+    end
+    @data[:parser].opt *args
+  end
+
+  def self.action & block
+    @data[:action] = block
+  end
+
+  def self.script inline: nil, path: nil, vars: nil
+    if !inline.nil? && !path.nil?
+      raise Rbcli::CommandError.new "Can't assign both an inline script and an external path to command '#{self.name}'"
+    end
+    if path == :builtin or path.nil?
+      callerscript = caller_locations.first.absolute_path
+      path = "#{File.dirname(callerscript)}/scripts/#{File.basename(callerscript, ".*")}.sh"
+    end
+    require File.join(RBCLI_LIBDIR, 'components', 'scriptwrapper', 'scriptwrapper.rb')
+    @data[:script] = Rbcli::ScriptWrapper.new inline: inline, path: path, vars: vars
+  end
+end

data/lib/rbcli/components/commands/script.rb.erb

@@ -0,0 +1,43 @@
+<%- if @showdocs -%>
+# Script Command
+# Supports all of the same features as a regular command, but passes everything to a bash script
+# The script can be defined inline, or a path to an external script can be provided
+#
+# Code is injected into the script to integrate with Rbcli.
+#   The `log` commands are integrated with the ruby logger
+#   The `rbcli` command provides a wrapper around jq that can retrieve
+#     the values of opts/params/args/config/env
+#   For more information on JQ syntax, see: https://jqlang.github.io/jq/
+<%- end -%>
+Rbcli.command "<%= @command_name || 'script' %>" do
+  description "example script command"
+  # external_script vars: {}, path: "./test.sh"
+  inline_script vars: { foo: 'bar!!!' }, inline: <<~INLINE
+    #!/usr/bin/env bash
+    log "Rbcli shell integration demo!"
+    <%- if @showdocs -%>
+    log "A custom JQ wrapper is used to parse data passed through from Rbcli"
+    log "For more information on how to use it, see: https://jqlang.github.io/jq/"
+    log ""
+
+    log "Top-level CLI Options: $(rbcli opts .)"
+    log "Parameters: $(rbcli params .)"
+    log "Arguments on the CLI: $(rbcli args .)"
+    log "Config: $(rbcli config .)"
+    log "Environment Variables: $(rbcli env .)"
+    log "Custom Var from command: $(rbcli vars .foo)"
+    log "Same variable, in environment: ${FOO}"
+
+    log "Logs are integrated too"
+    log "Example Debug (you need to change your log level to see this)" "debug"
+    log "Example Info" "info"
+    log "Example Warning" "warn"
+    log "Example Error" "error"
+    log "Example Fatal" "fatal"
+    log "Example Unknown" "unknown"
+    <%- else -%>
+    rbcli opts .
+    log "Example Warning" "warn"
+    <%- end -%>
+  INLINE
+end

data/{lib-sh → lib/rbcli/components/commands/scriptwrapper}/lib-rbcli.sh

@@ -1,38 +1,33 @@
 #!/usr/bin/env bash
 ##################################################################################
-#     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>                        #
 ##################################################################################
-
-## Log message
+## Basic message
 function message {
 	if [ "$2" == "err" ]; then
 		COLOR='\033[00;31m'
 	else
-
 		COLOR='\033[00;32m'
 	fi
 
 	if [ "$2" == "no_newline" ]; then
-		printf "${COLOR}[RBCLI-Setup] ${1}\033[0m"
+		printf "${COLOR}${1}\033[0m"
 	else
-		echo -e "${COLOR}[RBCLI-Setup] ${1}\033[0m"
+		echo "${COLOR}${1}\033[0m"
+	fi
+}
+
+## Log function integrates with Rbcli Logger
+function log {
+	prefix='INFO || '
+	if [ ! -z ${2+x} ]; then
+		_pfx="$(echo "${2}" | tr '[:lower:]' '[:upper:]')"
+		if [[ "${_pfx}" =~ ^(DEBUG|INFO|WARN|ERROR|FATAL|UNKNOWN)$ ]]; then
+			prefix="${_pfx} || "
+		fi
 	fi
+	echo "${prefix}${1}"
 }
 
 ## Detect OS
@@ -87,7 +82,6 @@ function install_jq {
 	esac
 }
 
-
 # We need to make sure JQ is installed so that we can parse variables
 which jq &> /dev/null
 _RESULT=$?
@@ -97,36 +91,37 @@ if [[ "${_RESULT}" -ne 0 ]]; then
 	install_jq
 fi
 
-
 ######
 ## RBCLI
 ######
-# This function provides an interface to the variables exposed by RBCli
+# This function provides an interface to the variables exposed by Rbcli
 function rbcli {
 	_vargroup=$1
 	_var=$2
 
 	case "${_vargroup}" in
+		opts)
+			_groupname='__RBCLI_OPTS'
+		;;
 		params)
 			_groupname='__RBCLI_PARAMS'
 		;;
 		args)
 			_groupname='__RBCLI_ARGS'
 		;;
-		global_opts)
-			_groupname='__RBCLI_GLOBAL'
-		;;
 		config)
 			_groupname='__RBCLI_CONFIG'
 		;;
-		myvars)
-			_groupname='__RBCLI_MYVARS'
+		env)
+			_groupname='__RBCLI_ENV'
+		;;
+		vars)
+			_groupname='__RBCLI_VARS'
 		;;
 		*)
-			message "Invalid RBCLI variable reference. Please reference variables from one of the following groups: params, args, global_opts, config, commandvars." "err"
+			message "Invalid RBCLI variable reference. Please reference variables from one of the following groups: opts, params, args, config, env, vars." "err"
 			exit 1
 	esac
-	echo $(echo ${!_groupname} | jq -r "${2}")
+	echo "$(echo ${!_groupname} | jq -r "${_var}")"
 }
-export -f rbcli
-
+export -f rbcli

data/lib/rbcli/components/commands/scriptwrapper/scriptwrapper.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'json'
+require 'open3'
+
+class Rbcli::ScriptWrapper
+  def initialize inline: nil, path: nil, vars: nil
+    @inline = inline
+    @path = path.nil? ? nil : File.expand_path(path)
+    @vars = vars || []
+  end
+
+  def execute opts = nil, params = nil, args = nil, config = nil, env = nil
+    sh_libpath = File.expand_path(File.join(File.dirname(__FILE__), 'lib-rbcli.sh'))
+    if @inline.nil? && !@path.nil?
+      cmd = File.read(@path).include?('lib-rbcli.sh') ? '' : "source '#{sh_libpath}'; "
+      cmd += "source '#{@path}'"
+      inject_rbcli = false
+    else
+      cmd = @inline
+      inject_rbcli = true
+    end
+    self.class.run_script cmd, opts: opts, params: params, args: args, config: config, env: env, vars: @vars, inject_rbcli: inject_rbcli
+  end
+
+  def self.run_script cmd, opts: nil, params: nil, args: nil, config: nil, env: nil, vars: nil, inject_rbcli: true,
+    capture_output: false, silent: false, prefix: nil, color: nil, bgcolor: nil
+    envs = {}
+    %w(opts params args config env vars).each do |k|
+      envs["__RBCLI_#{k.upcase}"] = eval("#{k}.nil?") ? [].to_json : eval("#{k}.to_json")
+    end
+    vars.each do |k, v|
+      envs[k.to_s.upcase] = v
+    end unless vars.nil?
+
+    if inject_rbcli && !cmd.include?('lib-rbcli.sh')
+      sh_libpath = File.expand_path(File.join(File.dirname(__FILE__), 'lib-rbcli.sh'))
+      cmd = cmd.lines.insert((cmd.start_with?('#!') ? 1 : 0), "source '#{sh_libpath}'\n").join
+    end
+
+    output = +''
+    retval = nil
+    prefix ||= ''
+    Open3.popen2e(envs, cmd) do |_stdin, stdout_and_stderr, wait_threads|
+      until (line = stdout_and_stderr.gets).nil? do
+        if line.include?(' || ')
+          severity, text = line.split(' || ', 2)
+        else
+          severity = 'INFO'
+          text = line
+        end
+        output << text
+        Rbcli.log.add(Logger.const_get(severity.upcase.to_sym), prefix + text.chomp.colorize(color: color, background: bgcolor), 'SCRP') unless silent
+        Rbcli.log.add(-1, prefix + text.chomp.colorize(color: color, background: bgcolor), 'SCRP') if silent
+      end
+      retval = wait_threads.value
+    end
+    Rbcli.log.debug "Return value of script was: #{retval}", "SCRP"
+    capture_output ? output : retval.success?
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'fileutils'
+
+module Rbcli::UserConf
+end
+
+class Rbcli::UserConf::Backend
+  @registered_types = {}
+
+  def self.types
+    {
+      yaml: Proc.new { |filename| filename.is_a?(String) && (filename.downcase.end_with?('.yaml') || filename.downcase.end_with?('.yml')) },
+      json: Proc.new { |filename| filename.is_a?(String) && filename.downcase.end_with?('.json') },
+      ini: Proc.new { |filename| filename.is_a?(String) && filename.downcase.end_with?('.ini') },
+      toml: Proc.new { |filename| filename.is_a?(String) && filename.downcase.end_with?('.toml') },
+      env: Proc.new { |filename| false },
+      null: Proc.new { |filename| true }
+    }
+  end
+
+  def self.inherited(subklass)
+    @registered_types[subklass.name.split('::').last.sub(/Store$/, '').downcase.to_sym] = subklass
+  end
+
+  def self.create filename, type: nil
+    type ||= self.types.map { |slug, check| [slug, check.call(filename)] }.to_h.select { |slug, match| match }.first.first
+    type = type.to_s.downcase.to_sym
+    require_relative "backends/#{type.to_s}"
+    @registered_types[type].new(filename, type)
+  end
+
+  def initialize filename, type
+    @path = File.expand_path(filename)
+    @path = File.realpath(@path) if File.symlink?(@path)
+    @type = type.to_s.capitalize
+    @loaded = false
+  end
+
+  attr_reader :type, :loaded
+  alias_method :loaded?, :loaded
+
+  # The defaults: parameter is used on some backends to know which fields to expect and parse
+  def load defaults: nil
+    begin
+      text = File.read(@path)
+    rescue Errno::ENOENT => _
+      Rbcli.log.debug "Attempted to load #{@type} config file but did not find it at '#{@path}'", "CONF"
+    else
+      Rbcli.log.debug "Loaded #{@type} config file at '#{@path}'", "CONF"
+      self.parse(text)
+    end
+  end
+
+  def save hash
+    Rbcli.log.debug "Saving #{@type} config file at '#{@path}'", "CONF"
+    begin
+      File.write(@path, self.unparse(hash))
+    rescue Errno => err
+      Rbcli.log.error "Could not save config to file at '#{@path}'", "CONF"
+      Rbcli.log.error "Error: #{err.message}", "CONF"
+      false
+    else
+      hash
+    end
+  end
+
+  def savable?
+    File.writable?(File.exist?(@path) ? @path : File.dirname(@path))
+  end
+
+  def exist?
+    File.exist?(@path)
+  end
+
+  def annotate! defaults
+    begin
+      text = File.read(@path)
+    rescue Errno::ENOENT => _
+      Rbcli.log.debug "Attempted to annotate #{@type} config file but did not find it at '#{@path}'", "CONF"
+      return nil
+    end
+    Rbcli.log.debug "Annotating #{@type} config file at '#{@path}'", "CONF"
+
+    text = self.inject_banner(text, defaults[:helptext])
+    File.write(@path, text)
+
+    begin
+      File.write(@path, text)
+      Rbcli.log.debug "Saved #{@type} annotations at '#{@path}'", "CONF"
+    rescue Errno => err
+      Rbcli.log.error "Could not save annotations to '#{@path}'", "CONF"
+      Rbcli.log.error "Error: #{err.message}", "CONF"
+      return nil
+    else
+      return true
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require_relative 'helpers/deep_assign'
+
+class Rbcli::UserConf::Env < Rbcli::UserConf::Backend
+  include Rbcli::UserConf::Helpers::DeepAssign
+
+  def initialize prefix, type
+    @prefix = prefix
+    @type = type.to_s.capitalize
+    @loaded = false
+  end
+
+  def load defaults: nil
+    vars = ENV.select { |k, v| k.match(/^#{@prefix}_.+/i) && !k.match(/^_/) }
+    if @prefix.nil? && !defaults.nil? && !defaults.empty?
+      lowercase_default_keys = defaults.keys.map { |k| k.downcase.to_sym }
+      vars = vars.merge ENV.select { |k, v| lowercase_default_keys.include?(k.downcase.to_sym) }
+    end
+    vars = vars.map { |k, v| [k.split('_', 2).last.downcase, v] }.to_h
+    final_vars = Hash.new
+    vars.each do |key, value|
+      deep_assign(final_vars, key.split('_').map { |k| k.to_sym }, translate_value(value))
+    end
+    if @prefix.nil? && !defaults.nil? && !defaults.empty?
+      lowercase_default_keys = defaults.keys.map { |k| k.downcase.to_sym }
+      vars = ENV.select { |k, v| lowercase_default_keys.include?(k.downcase.to_sym) }.map { |k, v| [k.downcase.to_sym, v] }.to_h
+    end
+    @loaded = true
+    final_vars
+  end
+
+  def save hash, path = []
+    hash.each do |key, value|
+      if !value.is_a? Hash
+        ENV[([@prefix] + path + [key.upcase]).reject(&:nil?).join('_')] = (value.is_a?(Symbol) ? ':' : '') + value.to_s
+      else
+        save value, path + [key.upcase]
+      end
+    end
+  end
+
+  def parse_defaults defaults
+    final_vars = Hash.new
+    defaults.each do |key, value|
+      key_parts = key.to_s.split('_').map { |k| k.downcase.to_sym }
+      key_parts.delete_at(0) if key_parts.first == @prefix.to_s.downcase.to_sym
+      deep_assign(final_vars, key_parts, value.is_a?(String) ? translate_value(value) : value)
+    end
+    final_vars
+  end
+
+  def savable?
+    true
+  end
+
+  def exist?
+    true
+  end
+
+  def annotate! _defaults = nil
+    true
+  end
+end

data/lib/rbcli/components/config/backends/helpers/deep_assign.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require 'json'
+module Rbcli::UserConf::Helpers
+  module DeepAssign
+
+    private
+
+    def deep_assign hash, sections_arr, value
+      if sections_arr.length == 1
+        hash[sections_arr.first] = value
+      else
+        hash[sections_arr.first] ||= Hash.new
+        deep_assign(hash[sections_arr.first], sections_arr[1..-1], value)
+      end
+    end
+
+    def translate_value value
+      if value.nil?
+        nil
+      elsif value.start_with?(':')
+        value[1..-1].to_sym
+      elsif value.downcase == 'true'
+        true
+      elsif value.downcase == 'false'
+        false
+      elsif value.to_i.to_s == value
+        value.to_i
+      elsif value.start_with?('[') && value.end_with?(']') # array
+        begin
+          JSON.parse(value)
+        rescue JSON::ParserError => _err
+          value
+        end
+      else
+        begin
+          Float value
+        rescue => _err
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+##################################################################################
+#     Rbcli -- A framework for developing command line applications in Ruby      #
+#     Copyright (C) 2024 Andrew Khoury <akhoury@live.com>                        #
+##################################################################################
+require_relative 'helpers/deep_assign'
+
+class Rbcli::UserConf::Ini < Rbcli::UserConf::Backend
+  include Rbcli::UserConf::Helpers::DeepAssign
+
+  private
+
+  def parse str
+    ini = Hash.new
+    nest = []
+    str.lines.each_with_index do |line, i|
+      line = line.split(';').first.strip
+      next if line.nil? || line.empty?
+      if line =~ /^\[(.*)\]$/
+        nest = $1.split('.')
+      elsif line.include?('=')
+        key, value = line.split('=').map { |part| part.strip }
+        deep_assign(ini, nest + [key], translate_value(value))
+      else
+        Rbcli.log.warn "Invalid #{@type} syntax found on line #{i} at '#{@path}'. Offending syntax: #{line}", "CONF"
+        return Hash.new
+      end
+    end
+    @loaded = true
+    ini
+  end
+
+  def unparse hash
+    ini = []
+    parse_hash = Proc.new do |hsh, keys = []|
+      hsh.each do |key, val|
+        if !val.is_a?(Hash)
+          val = ":#{val.to_s}" if val.is_a?(Symbol)
+          ini << "#{key.to_s.strip} = #{val.to_s.strip}"
+        else
+          ini << '[' + (keys + [key]).join('.') + ']'
+          parse_hash.call(val, keys + [key])
+        end
+      end
+    end
+    parse_hash.call(hash)
+    ini.join("\n")
+  end
+
+  def inject_banner text, banner
+    banner.lines.map { |line| "; #{line.chomp}" }.join("\n") + "\n" + text
+  end
+end

data/lib/rbcli/components/config/backends/json.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>                        #
+##################################################################################
+require 'json'
+
+class Rbcli::UserConf::Json < Rbcli::UserConf::Backend
+  private
+
+  def parse str
+    begin
+      parsed_str = JSON.parse(str)
+    rescue JSON::JSONError => 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
+    JSON.pretty_generate(hash)
+  end
+
+  def inject_banner text, _banner
+    text
+  end
+
+end

data/lib/rbcli/components/config/backends/null.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>                        #
+##################################################################################
+class Rbcli::UserConf::Null < Rbcli::UserConf::Backend
+  def initialize filename, type
+    @type = type.to_s.upcase
+    @loaded = false
+  end
+
+  def load defaults: nil
+    @loaded = true
+    {}
+  end
+
+  def save hash
+    hash
+  end
+
+  def savable?
+    true
+  end
+
+  def exist?
+    true
+  end
+
+  def annotate! _defaults = nil
+    true
+  end
+end