rbcli 0.1.0

data/lib/rbcli/engine/command.rb

@@ -0,0 +1,179 @@
+class Rbcli::Command
+
+	#include InheritableTraits
+	#traits :description
+
+	@commands = {}
+
+	def self.inherited subklass
+		@commands[subklass.name.downcase] = subklass.new
+	end
+
+	def self.add_command name, klass
+		@commands[name.downcase] = klass.new
+	end
+
+	def self.commands
+		@commands
+	end
+
+	##
+	# Interface Functions
+	##
+	def self.description desc;     @desc = desc end
+	def      description;          self.class.instance_variable_get :@desc end
+
+	def self.usage usage;          @usage = usage end
+	def      usage;                self.class.instance_variable_get :@usage end
+
+	def self.action █        @action = block end
+	def      action;               self.class.instance_variable_get :@action end
+
+	def self.parameter name, description, type: :boolean, default: nil, required: false
+		@paramlist ||= {}
+		@paramlist[name.to_sym] = {
+				description: description,
+				type: type,
+				default: default,
+				required: required
+		}
+	end
+	def      paramlist;               self.class.instance_variable_get :@paramlist end
+
+	def self.config_defaults filename
+		Rbcli::Config::add_defaults filename
+	end
+
+	def self.config_default *params
+		Rbcli::Config::add_default *params
+	end
+
+	##
+	# END Interface Functions
+	##
+
+	##
+	# Run a given command
+	##
+	def self.runcmd cmd, local_params, cliopts
+		args = local_params.delete :args
+		params = local_params
+		global_opts = cliopts
+		config = Rbcli::config
+
+		@commands[cmd].action.call params, args, global_opts, config
+	end
+
+	##
+	# Returns all descriptions for display in CLI help
+	##
+	def self.descriptions indent_size, justification
+		#descmap = @commands.map { |name, klass| [name, klass.description] }.to_h
+		@commands.map do |name, cmdobj|
+			desc = ''
+			indent_size.times { desc << ' ' }
+			desc << name.ljust(justification)
+			desc << cmdobj.description
+		end.join("\n")
+	end
+
+	##
+	# This method reads the parameters provided by the class and parses them from the CLI
+	##
+	def parseopts *args
+		params = paramlist
+		command_name = self.class.name.split('::')[-1].downcase
+		command_desc = description
+		command_usage = usage
+		optx = Trollop::options do
+			data = Rbcli.configuration
+			banner <<-EOS
+#{data[:description]}
+Selected Command:
+      #{command_name.ljust(21)}#{command_desc}
+
+Usage:
+      #{data[:scriptname]} [options] #{command_name} [parameters]
+
+#{command_usage}
+
+Command-specific Parameters:
+			EOS
+			params.each do |name, opts|
+				opt name, opts[:description], type: opts[:type], default: opts[:default], required: opts[:required]
+			end if params.is_a? Hash
+		end
+		optx[:args] = ARGV
+		optx
+	end
+
+	##
+	# Inject metadata into response
+	##
+	# def self.wrap_metadata resp
+	# 	{
+	# 			meta: {
+	# 					status: 'ok',
+	# 					timestamp: (Time.now.to_f * 1000).floor
+	# 			},
+	# 			response: resp
+	# 	}.deep_stringify!
+	# end
+
+	####
+	### DEPRECATED
+	####
+	# Now we automatically pull in the plugins and register them as commands.
+	# Note that filenames must be the same as the class name and are case
+	# sensitive. Only one class per file.
+	##
+	# This is commented out as this functionality is deprecated. Instead we rely on subclassing to
+	# add the commands.
+	###
+	# Dir.glob("#{File.dirname(__FILE__)}/commands/*.rb") do |f|
+	# 	Rbcli::log.debug {"Loading CLI command #{f.split('commands/')[1].split('.')[0]}"}
+	# 	require f
+	# 	klassname = "Rbcli::Command::#{f.match(/.*\/([^\/]+)\.rb$/i)[1].capitalize}"
+	# 	klass = Object.const_get(klassname)
+	# 	klass.send :include, Rbcli::Command
+	# 	self.add_command klassname.split('::')[-1], klass
+	# end
+
+end
+
+
+# module InheritableTraits
+#
+# 	def self.included(base)
+# 		base.extend ClassMethods
+# 	end
+#
+# 	module ClassMethods
+# 		def traits(*attrs)
+# 			@traits ||= []
+# 			@traits += attrs
+# 			attrs.each do |attr|
+# 				class_eval %{
+#           def self.#{attr}(string = nil)
+#             @#{attr} = string || @#{attr}
+#           end
+#           def self.#{attr}=(string = nil)
+#             #{attr}(string)
+#           end
+#         }
+# 			end
+# 			@traits
+# 		end
+#
+# 		def inherited(subclass)
+# 			(["traits"] + traits).each do |t|
+# 				ivar = "@#{t}"
+# 				subclass.instance_variable_set(
+# 						ivar,
+# 						instance_variable_get(ivar)
+# 				)
+# 			end
+# 		end
+# 	end
+#
+# end

data/lib/rbcli/engine/parser.rb

@@ -0,0 +1,68 @@
+require 'trollop'
+
+module Rbcli::Parser
+
+	@cliopts = nil
+
+	def self.parse
+		@cliopts = Trollop::options do
+			data = Rbcli.configuration
+			version "#{data[:scriptname]} version: #{data[:version]}"
+			banner <<-EOS
+#{data[:description]}
+For more information on individual commands, run `#{data[:scriptname]} <command> -h`.
+
+Usage:
+      #{data[:scriptname]} [options] command [parameters]
+
+Commands:
+#{Rbcli::Command.descriptions 6, 21}
+
+[options]:
+			EOS
+			data[:options].each do |name, opts|
+				opt name.to_sym, opts[:description], type: opts[:type], default: opts[:default]
+			end
+			opt :json_output, 'Output result in machine-friendly JSON format', :type => :boolean, :default => false if data[:allow_json]
+			opt :config_file, 'Specify a config file manually', :type => :string, :default => data[:config_userfile]
+			opt :generate_config, 'Generate a new config file' #defaults to false
+			stop_on Rbcli::Command.commands.keys
+		end
+
+		@cmd = [ARGV.shift] # get the subcommand
+		if @cliopts[:generate_config]
+			Rbcli::Config::generate_userconf @cliopts[:config_file]
+			puts "User config generated at #{@cliopts[:config_file]} using default values."
+		elsif @cmd[0].nil?
+			if Rbcli.configuration[:default_action].nil?
+				Trollop::educate
+			else
+				Rbcli.configuration[:default_action].call @cliopts
+			end
+		elsif Rbcli::Command.commands.key? @cmd[0]
+			@cmd << Rbcli::Command.commands[@cmd[0]].parseopts
+
+			Rbcli.configuration[:pre_hook].call @cliopts unless Rbcli.configuration[:pre_hook].nil?
+			Rbcli::Command.runcmd(@cmd.shift, @cmd[0], @cliopts)
+			Rbcli.configuration[:post_hook].call @cliopts unless Rbcli.configuration[:pre_hook].nil?
+		else
+			Trollop::die "Unknown subcommand #{@cmd[0].inspect}"
+		end
+
+	end
+
+	def self.opts
+		@cliopts
+	end
+
+	def self.cmd
+		@cmd
+	end
+
+end
+
+module Rbcli
+	def self.parse
+		Rbcli::Parser::parse
+	end
+end

data/lib/rbcli/util/config.rb

@@ -0,0 +1,140 @@
+####
+# Config Module
+####
+# The config module manages two distinct sets of config: one is the user's, and one is the application's default.
+# This allows you to set default values for your configuration files, and can use the default values to generate a
+# new user config file at any time by writing them to a file.
+#
+# Usage
+#
+# Rbcli::config[:key]
+#   Provides access to config file hash values under :key.
+#   Note the lowercase 'c' in config, which is different from the rest of the functions below.
+#
+# Rbcli::Config::set_file(filename, autoload:true, merge_defaults: false)
+#   This function allows you to set the path for the user's config file (eg: /etc/myscript/config.yml).
+#     autoload will load the file at the same time
+#     merge_defaults will fill in missing values in the user's config with default ones
+#
+# Rbcli::Config::add_defaults(filename)
+#   This function loads the contents of a YAML or JSON file into the default config. Used for custom configuration.
+#
+# Rbcli::Config::load
+#   This forces a reload of the config file.
+#
+# Rbcli::Config::generate_userconf
+#   This writes the config defaults to the filename set using the set_file command.
+####
+
+require 'yaml'
+require 'fileutils'
+require 'deep_merge'
+
+module Rbcli
+	def self.config
+		Rbcli::Config::config
+	end
+end
+
+module Rbcli::Config
+
+	@config = nil
+	@config_file = nil
+	@config_defaults = nil
+	@merge_defaults = false
+	@categorized_defaults = nil
+	@loaded = false
+
+	def self.set_userfile filename, merge_defaults: false, required: false
+		@config_file = filename
+		@merge_defaults = merge_defaults
+		@userfile_required = required
+		@loaded = false
+	end
+
+	def self.add_categorized_defaults name, description, config
+		@categorized_defaults ||= {}
+		@categorized_defaults[name.to_sym] = {
+				description: description,
+				config: config
+		}
+
+		@config_defaults ||= {}
+		@config_defaults[name.to_sym] = {}
+		config.each do |k, v|
+			@config_defaults[name.to_sym][k.to_sym] = v[:value]
+		end
+		@loaded = false
+	end
+
+	def self.add_default name, description: nil, value: nil
+		@config_individual_lines ||= []
+		text = "#{name.to_s}: #{value}".ljust(30) + " # #{description}"
+		@config_individual_lines.push text unless @config_individual_lines.include? text
+		@config_defaults[name.to_sym] = value
+		@loaded = false
+	end
+
+	def self.add_defaults filename=nil, text: nil
+		return unless filename and File.exists? filename
+		@config_text ||= ''
+		@config_text += "\n" unless @config_text.empty?
+		File.readlines(filename).each do |line|
+			if (line.start_with? '---' or line.start_with? '...')
+				@config_text << "\n\n"
+			else
+				@config_text << line unless @config_text.include? line
+			end
+		end if filename and File.exists? filename
+		@config_text << "\n\n" << text if text
+
+		@config_defaults ||= {}
+		@config_defaults.deep_merge! YAML::load(@config_text).deep_symbolize!
+		@loaded = false
+	end
+
+	def self.load
+		if (! @config_file.nil?) and File.exists? @config_file
+			@config = YAML::load(File.read(@config_file)).deep_symbolize!
+			@config.deep_merge! @config_defaults if @merge_defaults
+		elsif @userfile_required
+			puts "User's config file not found at #{@config_file}. Please run this tool with the -g option to generate it."
+			exit 1
+		else
+			@config = @config_defaults
+		end
+		@loaded = true
+		@config
+	end
+
+	def self.config
+		self.load unless @loaded
+		(@config.nil?) ? @config_defaults : @config
+	end
+
+	def self.generate_userconf filename
+		filepath = "#{(filename) ? filename : "#{Dir.pwd}/config.yml"}"
+		File.write filepath, @config_text
+		File.open(filepath, 'a') do |f|
+			f.puts "# Individual Settings"
+			@config_individual_lines.each { |l| f.puts l }
+		end if @config_individual_lines
+
+
+		if @categorized_defaults
+			text = ''
+			@categorized_defaults.each do |name, opts|
+				text += "\n# #{opts[:description]}\n"
+				text += "#{name.to_s}:\n"
+				opts[:config].each do |opt, v|
+					text += "  #{opt.to_s}: #{v[:value]}".ljust(30) + " # #{v[:description]}\n"
+				end
+			end
+			File.open(filepath, 'a') do |f|
+				f.puts text
+			end
+		end
+	end
+
+end
+

data/lib/rbcli/util/hash_deep_symbolize.rb

@@ -0,0 +1,28 @@
+##
+# 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_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/logging.rb

@@ -0,0 +1,73 @@
+####
+# Logging Module
+####
+# The logging module automatically initializes and formats the Ruby logger, and makes it available for the application.
+# Note that all of the built-in log commands are available.
+#
+# Additionally, a convenience function Rbcli::debug is available, which does not log, but prints an object.to_s
+# in red so that it is easily identifiable in the coutput.
+#
+# Usage
+#
+# Rbcli::log.info {'Some Message'}
+#
+# Rbcli::debug myobj
+#
+####
+
+require 'logger'
+require 'colorize'
+
+module Rbcli::Logger
+
+	@default_level = 'info'
+	@default_target = 'stderr'
+
+	def self.save_defaults level: nil, target: nil
+		@default_level = level if level
+		@default_target = target if target
+
+		Rbcli::Config::add_categorized_defaults :logger, 'Log Settings', {
+				log_level: {
+						description: '0-5, or DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN',
+						value: @default_level || 'info'
+				},
+				log_target: {
+						description: 'STDOUT, STDERR, or a file path',
+						value: @default_target || 'stderr'
+				}
+		}
+	end
+	self.save_defaults
+
+
+	if Rbcli::config[:logger][:log_target].downcase == 'stdout'
+		target = STDOUT
+	elsif Rbcli::config[:logger][:log_target].downcase == 'stderr'
+		target = STDERR
+	else
+		target = Rbcli::config[:logger][:log_target]
+	end
+	@logger = Logger.new(target)
+	@logger.level = Rbcli::config[:logger][:log_level]
+
+	original_formatter = Logger::Formatter.new
+	@logger.formatter = proc do |severity, datetime, progname, msg|
+		original_formatter.call(severity, datetime, progname || caller_locations[3].path.split('/')[-1], msg.dump)
+	end
+
+	def self.log
+		@logger
+	end
+
+end
+
+module Rbcli
+	def self.log
+		Rbcli::Logger::log
+	end
+
+	def self.debug obj
+		puts obj.to_s.red
+	end
+end

data/lib/rbcli/util/string_colorize.rb

@@ -0,0 +1,25 @@
+class String
+	def black;          "\e[30m#{self}\e[0m" end
+	def red;            "\e[31m#{self}\e[0m" end
+	def green;          "\e[32m#{self}\e[0m" end
+	def brown;          "\e[33m#{self}\e[0m" end
+	def blue;           "\e[34m#{self}\e[0m" end
+	def magenta;        "\e[35m#{self}\e[0m" end
+	def cyan;           "\e[36m#{self}\e[0m" end
+	def gray;           "\e[37m#{self}\e[0m" end
+
+	def bg_black;       "\e[40m#{self}\e[0m" end
+	def bg_red;         "\e[41m#{self}\e[0m" end
+	def bg_green;       "\e[42m#{self}\e[0m" end
+	def bg_brown;       "\e[43m#{self}\e[0m" end
+	def bg_blue;        "\e[44m#{self}\e[0m" end
+	def bg_magenta;     "\e[45m#{self}\e[0m" end
+	def bg_cyan;        "\e[46m#{self}\e[0m" end
+	def bg_gray;        "\e[47m#{self}\e[0m" end
+
+	def bold;           "\e[1m#{self}\e[22m" end
+	def italic;         "\e[3m#{self}\e[23m" end
+	def underline;      "\e[4m#{self}\e[24m" end
+	def blink;          "\e[5m#{self}\e[25m" end
+	def reverse_color;  "\e[7m#{self}\e[27m" end
+end

data/lib/rbcli/util.rb

@@ -0,0 +1,4 @@
+require 'rbcli/util/hash_deep_symbolize'
+#require 'rbcli/util/string_colorize' # We are using the colorize gem instead. The code is kept here for reference.
+require 'rbcli/util/config'
+require 'rbcli/util/logging'

data/lib/rbcli/version.rb

@@ -0,0 +1,3 @@
+module Rbcli
+  VERSION = "0.1.0"
+end

data/lib/rbcli.rb

@@ -0,0 +1,11 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+module Rbcli end # Empty module declaration required to declare submodules freely
+require "rbcli/version"
+
+require "rbcli/util"
+require "rbcli/configurate"
+
+require "rbcli/engine/command"
+require "rbcli/engine/parser"

data/rbcli.gemspec

@@ -0,0 +1,42 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rbcli/version"
+
+Gem::Specification.new do |spec|
+	spec.name          = 'rbcli'
+	spec.version       = Rbcli::VERSION
+	spec.authors       = ['Andrew Khoury']
+	spec.email         = ['akhoury@live.com']
+
+	spec.summary       = %q{A CLI Framework for Ruby}
+	spec.description   = %q{RBCli is a framework to quickly develop command-line tools.}
+	spec.homepage      = 'https://github.com/akhoury6/rbcli'
+	spec.license       = 'MIT'
+
+	# Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+	# to allow pushing to a single host or delete this section to allow pushing to any host.
+	# if spec.respond_to?(:metadata)
+	# 	spec.metadata["allowed_push_host"] = "http://mygemserver.com"
+	# else
+	# 	raise "RubyGems 2.0 or newer is required to protect against " \
+	# 		"public gem pushes."
+	# end
+
+	# Specify which files should be added to the gem when it is released.
+	# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+	spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+		`git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+	end
+	spec.bindir        = 'exe'
+	spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+	spec.require_paths = ['lib']
+
+	spec.add_development_dependency 'bundler', '~> 1.16'
+	spec.add_development_dependency 'rake', '~> 10.0'
+	spec.add_development_dependency 'minitest', '~> 5.0'
+
+	spec.add_dependency 'colorize', '~> 0.8'
+	spec.add_dependency 'deep_merge', '~> 1.2'
+	spec.add_dependency 'trollop', '~> 2.1'
+end