rbcli 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75d0190f4a13b9cb6b42eb88b481d30490e5c1cc033cbb55d9d80894e2765ccd
-  data.tar.gz: 2aebd4cf49b7c61107bdcbac02e2caf2f8572705231a5481b482709efbb7419d
+  metadata.gz: 3f1de334efcc5489a103f4001a64d40a347d8aac715566682001e50600e596af
+  data.tar.gz: ecd300a10c89299f987d1031fff974cf7e45bc31ff56af20871462c98a2e833d
 SHA512:
-  metadata.gz: 4bb27dbc682773ee1e9b5c29ffc4da1dcd68c89b3f42acf0818459bee9b1aba0c6a9885c4b5b52b9fb7ddacb96cf34c5d327b935e4ca6bcdab316fd780e42b5e
-  data.tar.gz: 25a891ccf9beb709c898d4c1951c6ee3cc703b2991a2259b175fe61c2e100a716ab8bc9b2b2f1f025a2e3fa51863a2211712059025803a19f9b8d64aef29721b
+  metadata.gz: 1c954de05e3383d692e16cc6eb238add53b4e24758f81440ea5601ec10be780e12df6ed3358dd539494dc731ffca0fe4457021a566003af7ddbb4b21f4ef05b7
+  data.tar.gz: 879bb9c5627c7118ae7bf8c319ade644aa48191eca455ccfeaf7f910e1f56c33b1f2ee38b1ed727a429b4e272e780af0756b940c1782f7ec6f8737751e6e1950

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rbcli (0.1.9)
+    rbcli (0.1.10)
       aws-sdk-dynamodb (~> 1.6)
       colorize (~> 0.8)
       deep_merge (~> 1.2)

data/README.md

@@ -31,7 +31,7 @@ Some of its key features include:
 
 ## Installation
 
-RBCli is available on rubygems.org. You can add it to your application's `Gemrile` or `gemspec`, or install it manually via `gem install rbcli`.
+RBCli is available on rubygems.org. You can add it to your application's `Gemfile` or `gemspec`, or install it manually via `gem install rbcli`.
 
 
 ## The Basics
@@ -217,7 +217,8 @@ The user chain has two functions: generating and loading configuration from a YA
 Rbcli will determine the correct location to locate the user configuration based on two factors:
 
 1. The default location set in the configurate DSL
-	a. `config_userfile '/etc/mytool/config.yml', merge_defaults: true, required: false  # (Optional) Set location of user's config file. If merge_defaults=true, user settings override default settings, and if false, defaults are not loaded at all. If required=true, application will not run if file does not exist.`
+	a. `config_userfile '/etc/mytool/config.yml', merge_defaults: true, required: false`
+	b. (Optional) Set location of user's config file. If `merge_defaults=true`, user settings override default settings, and if `false`, defaults are not loaded at all. If `required=true`, application will not run if file does not exist.
 2. The location specified on the command line using the `-c <filename>` option
 	b. `yourclitool -c localfile.yml`
 
@@ -469,7 +470,7 @@ As you can see above, items which have nested values they are passed in as JSON.
 
 ### Variable Path Mode
 
-Variable Path Mode works the same as Direct Path Mode, only instead of providing a string we provide a block that returns a string. This allows us to generate different commands based on the CLI parameters that the user passed:
+Variable Path Mode works the same as Direct Path Mode, only instead of providing a string we provide a block that returns a string. This allows us to generate different commands based on the CLI parameters that the user passed, or pass configuration as CLI parameters to the external application:
 
 ```ruby
 class Test < Rbcli::Command                                                          # Declare a new command by subclassing Rbcli::Command
@@ -478,7 +479,7 @@ class Test < Rbcli::Command
 	parameter :force, 'Force testing', type: :boolean, default: false, required: false # (Optional, Multiple) Add a command-specific CLI parameter. Can be called multiple times
 
 	extern envvars: {MY_OTHER_VAR: 'another_value'} do |params, args, global_opts, config|                   # Alternate usage. Supplying a block instead of a path allows us to modify the command based on the arguments and configuration supplied by the user.
-		if params[:force].to_s
+		if params[:force]
 			"externalapp --test-script foo --ignore-errors"
 		else
 			"externalapp"
@@ -517,10 +518,11 @@ It is highly recommended to __not__ create files in these folders manually, and
 rbcli command -n <name>
 rbcli script -n <name>
 rbcli userconf -n <name>
-rbcli hook -t pre
-rbcli hook -t post
-rbcli hook -t default
-rbcli hook -t runonce
+rbcli hook --default      # or rbcli hook -d
+rbcli hook --pre          # or rbcli hook -p
+rbcli hook --post         # or rbcli hook -o
+rbcli hook --firstrun     # or rbcli hook -f
+rbcli hook -dpof          # all hooks at once
 ```
 
 That said, this readme will provide you with the information required to do things manually if you so desire. More details on generators later.

data/exe/rbcli

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'rbcli'
+require "#{File.dirname(__FILE__)}/../lib/rbcli.rb"
 
 Rbcli::Configurate.me do
 	scriptname __FILE__.split('/')[-1]
@@ -8,7 +8,7 @@ Rbcli::Configurate.me do
 	description 'RBCli initialization tool'
 end
 
-require 'rbcli-tool'
+require "#{File.dirname(__FILE__)}/../lib/rbcli-tool.rb"
 
 class Docs < Rbcli::Command
 	description 'Show Documentation (Beta)'
@@ -37,7 +37,7 @@ Mini:     A single-file RBCli project. All features are supported, but project s
 
 Micro:    A single-file, minimal RBCli project. Similar to a mini project, but only the minimal required code is
           generated. Recommended for rapid prototyping of scripts, for advanced users only.
-	EOF
+EOF
 
 	parameter :name, 'Name of project to generate', type: :string, required: true
 	parameter :type, 'Specify project type', type: :string, permitted: %w(standard micro mini), default: 'standard'
@@ -55,47 +55,134 @@ Micro:    A single-file, minimal RBCli project. Similar to a mini project, but o
 
 		proj = RBCliTool::Project.new(dest, template_vars)
 
-		if proj.exists?
-			RBCliTool.continue_confirmation "The project or file #{params[:name]} already exists; contents will be overwritten."
-			FileUtils.rm_rf dest
-		end
+		# if proj.exists?
+		# 	RBCliTool.continue_confirmation "The project or file #{params[:name]} already exists; contents will be overwritten."
+		# 	FileUtils.rm_rf dest
+		# end
 
 		case params[:type]
 		when 'micro' # Micro: Single File, simplified
-			puts "\nInitialization Complete!\n" if proj.create_micro
-
+			success = proj.create_micro
 		when 'mini' # Mini: Single File
-			puts "\nInitialization Complete!\n" if proj.create_mini
-
+			success = proj.create_mini
 		else # Standard; full project structure
-			if proj.create
-				puts "\nInitialization Complete!\n"
-			else
-				puts "\nAn RBCli Project already exists in the current directory tree at: #{proj.exists?}. Aborting.\n"
-			end
-
+			success = proj.create
 		end # END case params[:type]
 
+		if success
+			puts "\nInitialization Complete!\n"
+		else
+			puts "\nAn RBCli Project already exists in the current directory tree at: #{proj.exists?}. Please delete the project or run this command from a different directory.\n"
+		end
 	end
 end
 
 class Command < Rbcli::Command
 	description 'Generate an Rbcli Command under the current project'
 	usage <<-EOF
-This will generate a new project structure under the current directory. Use -t to specify the type:
+This will generate a new command under the current RBCli project.
 
+Please run this command from within the project's directory structure.
+EOF
 
-Standard: A complete RBCli project structure. Recommended for most applications, it provides
-          a framework for organizing code and creating a gem to be installed/distributed.
+	parameter :name, 'Name of command to generate', type: :string, required: true
+	parameter :description, 'A short description of the command', type: :string, default: 'TODO: Description goes here'
+	parameter :usagetext, 'Usage help text for the command', type: :string, default: 'TODO: Usage text goes here'
 
-Mini:     A single-file RBCli project. All features are supported, but project structure is left to the developer.
-          Recommended for smaller applications, or for integrating RBCli into an existing application.
+	action do |params, args, global_opts, config|
+		# First we check that we are working within a project folder
+		project_root = RBCliTool::Project.find_root(Dir.pwd)
+		RBCliTool.exit_with_error("Can't find the project root in the current path. Please `cd` to your project's directory before running this command, and ensure that the `.rbcli` file is present in its root path.") unless project_root
 
-Micro:    A single-file, minimal RBCli project. Similar to a mini project, but only the minimal required code is
-          generated. Recommended for rapid prototyping of scripts, for advanced users only.
-	EOF
+		# Prepare template vars
+		template_vars = {
+				name: params[:name],
+				description: params[:description],
+				usage_text: params[:usagetext],
+				rbcli_version: Rbcli::VERSION
+		}
+
+		generator = RBCliTool::Generator.new(:command, project_root, template_vars)
+		generator.run
+	end
+end
+
+class Extern < Rbcli::Command
+	description 'Generate an Rbcli Command with Bash Script under the current project'
+	usage <<-EOF
+This will generate a new command under the current RBCli project, and a skeleton bash script to code it.
+
+Use this option if you prefer to use bash (or another shell) to script your command, or if you need to integrate with
+a third party application.
+
+Please run this command from within the project's directory structure.
+EOF
 
 	parameter :name, 'Name of command to generate', type: :string, required: true
+	parameter :description, 'A short description of the command', type: :string, default: 'TODO: Description goes here'
+	parameter :usagetext, 'Usage help text for the command', type: :string, default: 'TODO: Usage text goes here'
+	parameter :skip_script, 'Skip creating a bash script and set executable path manually', type: :boolean, default: false
+
+	action do |params, args, global_opts, config|
+		# First we check that we are working within a project folder
+		project_root = RBCliTool::Project.find_root(Dir.pwd)
+		RBCliTool.exit_with_error("Can't find the project root in the current path. Please `cd` to your project's directory before running this command, and ensure that the `.rbcli` file is present in its root path.") unless project_root
+
+		# Prepare template vars
+		template_vars = {
+				name: params[:name],
+				description: params[:description],
+				usage_text: params[:usagetext],
+				no_script: params[:skip_script],
+				rbcli_version: Rbcli::VERSION
+		}
+
+		generator = RBCliTool::Generator.new(:extern, project_root, template_vars)
+		generator.run
+	end
+end
+
+class Hook < Rbcli::Command
+	description 'Generate an Rbcli Hook under the current project'
+	usage <<-EOF
+This will generate one or more execution hooks for the current project.
+
+Default:    The default hook runs whenever the user does not specify a command. If the hook is not present, the default
+            behavior is to show the help text (same as -h).
+
+Pre:        The pre-execution hook, which runs code prior to the execution of any command. This allows for actions such
+            as authentiation into remote systems.
+
+Post:       The post-execution hook, which runs code after the execution of any command.
+
+First-run:  The first-run hook will run only on the first time the user runs the application. This is useful for
+            initial setup or for welcome messages to be shown. Note that if you enable the first-run hook, you must
+            also enable local_state (see config/storage.rb).
+
+Please run this command from within the project's directory structure.
+EOF
+
+	parameter :default, 'Generate the default (no-command-entered) hook', type: :boolean, default: false
+	parameter :pre, 'Generate the pre-execution hook', type: :boolean, default: false
+	parameter :post, 'Generate the post-execution hook', type: :boolean, default: false
+	parameter :firstrun, 'Generate the first-run hook', type: :boolean, default: false
+
+	action do |params, args, global_opts, config|
+		# First we check that we are working within a project folder
+		project_root = RBCliTool::Project.find_root(Dir.pwd)
+		RBCliTool.exit_with_error("Can't find the project root in the current path. Please `cd` to your project's directory before running this command, and ensure that the `.rbcli` file is present in its root path.") unless project_root
+
+		generated_something = false
+
+		[:default, :pre, :post, :firstrun].each do |pname|
+			next unless params[pname]
+			generator = RBCliTool::Generator.new(:hook, project_root, pname)
+			generator.run
+			generated_something = true
+		end
+
+		RBCliTool.exit_with_error("No hooks specified. Please run `rbcli hooks -h` for details on how to generate hooks.") unless generated_something
+	end
 end
 
 

data/lib-sh/lib-rbcli.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+
+## Log 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"
+	else
+		echo -e "${COLOR}[RBCLI-Setup] ${1}\033[0m"
+	fi
+}
+
+## Detect OS
+function detect_os {
+	unameOut="$(uname -s)"
+	case "${unameOut}" in
+		Linux*)     machine=Linux;;
+		Darwin*)    machine=Darwin;;
+		CYGWIN*)    machine=Cygwin;;
+		MINGW*)     machine=MinGw;;
+		*)          machine="UNKNOWN:${unameOut}"
+	esac
+	echo ${machine}
+}
+
+## Install JQ
+function install_jq {
+	case "$(detect_os)}" in
+		Linux)
+			_tmpdir=$(mktemp -d)
+			_pwd=$(pwd)
+			cd $_tmpdir
+			curl -sOL "https://github.com/stedolan/jq/releases/download/jq-1.5/jq-linux64"
+			mv jq-linux64 /usr/bin/jq
+			cd $_pwd
+			rm -rf $_tmpdir
+			;;
+		Darwin*)
+			message "Apple OSX Detected; homebrew must be installed to continue. Continue? (Y/n): " "no_newline"
+			read -n1 _answer
+			printf "\n"
+			if [[ "${_answer}" =~ ^(y|Y)$ ]]; then
+				brew install jq
+			else
+				message "Installation aborted."
+				exit 0
+			fi
+			;;
+		*)
+			message "Sorry, your machine type ($(detect_os)) is not supported. This script can only install JQ automatically on either Linux or OSX."
+			message "Please visit https://stedolan.github.io/jq/ to install JQ manually on your system."
+			exit 0
+	esac
+}
+
+
+# We need to make sure JQ is installed so that we can parse variables
+which jq &> /dev/null
+_RESULT=$?
+if [[ "${_RESULT}" -ne 0 ]]; then
+	message "Application JQ not found on local system."
+	message "Installing JQ. Sudo access required, please input password if prompted."
+	install_jq
+fi
+
+
+######
+## RBCLI
+######
+# This function provides an interface to the variables exposed by RBCli
+function rbcli {
+	_vargroup=$1
+	_var=$2
+
+	case "${_vargroup}" in
+		params)
+			_groupname='__RBCLI_PARAMS'
+		;;
+		args)
+			_groupname='__RBCLI_ARGS'
+		;;
+		global_opts)
+			_groupname='__RBCLI_GLOBAL'
+		;;
+		config)
+			_groupname='__RBCLI_CONFIG'
+		;;
+		myvars)
+			_groupname='__RBCLI_MYVARS'
+		;;
+		*)
+			message "Invalid RBCLI variable reference. Please reference variables from one of the following groups: params, args, global_opts, config, commandvars." "err"
+			exit 1
+	esac
+	echo $(echo ${!_groupname} | jq -r "${2}")
+}
+export -f rbcli
+

data/lib/rbcli-tool.rb

@@ -11,6 +11,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 module RBCliTool end
 
+require 'rbcli-tool/util'
 require 'rbcli-tool/mdless_fix'
-require 'rbcli-tool/erb_renderer'
-require 'rbcli-tool/project'
+require 'rbcli-tool/project'
+require 'rbcli-tool/generators'

data/lib/rbcli-tool/generators.rb

@@ -0,0 +1,85 @@
+module RBCliTool
+	class Generator
+		def self.inherited(subklass)
+			@@types ||= {}
+			@@types[subklass.name.downcase.split('::')[1]] = subklass
+		end
+
+		def initialize type = nil, root_path = nil, template_vars = {}
+			@generator = @@types[type.to_s.downcase].new root_path, template_vars
+		end
+
+		def run *args
+			@generator.run *args
+		end
+	end
+
+	class Command < Generator
+		def initialize root_path, template_vars
+			@srcpath = "#{File.dirname(__FILE__)}/../../skeletons/project/application/commands/command.erb"
+			@dest = "#{root_path}/application/commands/#{template_vars[:name]}.rb"
+			@template_vars = template_vars
+		end
+
+		def run
+			if File.exists? @dest
+				RBCliTool.continue_confirmation "The command #{@template_vars[:name]} already exists; contents will be overwritten."
+				FileUtils.rm_rf @dest
+			end
+			RBCliTool.cp_file @srcpath, @dest, @template_vars
+		end
+	end
+
+	class Extern < Generator
+		def initialize root_path, template_vars
+			@filepaths = [
+					{
+							src: "#{File.dirname(__FILE__)}/../../skeletons/project/application/commands/script.erb",
+							dest: "#{root_path}/application/commands/#{template_vars[:name]}.rb"
+					}, {
+							src: "#{File.dirname(__FILE__)}/../../skeletons/project/application/commands/scripts/script.sh",
+							dest: "#{root_path}/application/commands/scripts/#{template_vars[:name]}.sh",
+							perms: 0755
+					}
+			]
+			@template_vars = template_vars
+			#@template_vars[:libsh_path] = Pathname.new("#{File.dirname(__FILE__)}/../../lib-sh/lib-rbcli.sh").cleanpath.to_s  # We clean this path because it will be visible to the user
+		end
+
+		def run
+			confirmed = false
+			@filepaths.each do |file|
+				next if file[:dest].end_with? '.sh' and @template_vars[:no_script]
+				if File.exists? file[:dest]
+					RBCliTool.continue_confirmation "The script command #{@template_vars[:name]} already exists; contents will be overwritten." unless confirmed
+					confirmed = true
+					FileUtils.rm_rf file[:dest]
+				end
+				RBCliTool.cp_file file[:src], file[:dest], @template_vars
+				File.chmod file[:perms], file[:dest] if file.key? :perms
+			end
+		end
+	end
+
+	class Hook < Generator
+		def initialize root_path, hook_type
+			@typename = {
+					default: 'default_action',
+					pre: 'pre_execution',
+					post: 'post_execution',
+					firstrun: 'first_run'
+			}[hook_type]
+			@src = "#{File.dirname(__FILE__)}/../../skeletons/project/hooks/#{@typename}.rb"
+			@dest = "#{root_path}/hooks/#{@typename}.rb"
+		end
+
+		def run
+			if File.exists? @dest
+				RBCliTool.continue_confirmation "The #{@typename} hook already exists; contents will be overwritten."
+				FileUtils.rm_rf @dest
+			end
+			RBCliTool.cp_file @src, @dest
+		end
+	end
+
+end

data/lib/rbcli-tool/project.rb

@@ -33,6 +33,7 @@ module RBCliTool
 
 			# Create executable
 			RBCliTool.cp_file "#{src}/exe/executable", "#{@dest}/exe/#{@template_vars[:cmdname]}", @template_vars
+			FileUtils.chmod 0755, "#{@dest}/exe/#{@template_vars[:cmdname]}"
 
 			# Create files for Gem package
 			Dir.entries(src).each do |file|
@@ -65,23 +66,26 @@ module RBCliTool
 			project_exists?
 		end
 
-		private
-
-		def project_exists?
-			# If the specified file already exists...
-			return true if File.exists? @dest
-
-			# Or if the .rbcli file exists anywhere in the tree...
-			searchpath = @dest
+		def self.find_root path
+			# We look for the .rbcli file in the current tree and return the root path
+			searchpath = path
 			while !searchpath.empty?
 				return searchpath if File.directory? searchpath and File.exists? "#{searchpath}/.rbcli"
 				spath = searchpath.split('/')
 				searchpath = (spath.length == 2) ? '/' : spath[0..-2].join('/')
 			end
-
-			# Otherwise we say the project does not exist
 			false
 		end
+
+		private
+
+		def project_exists?
+			# If the specified file already exists...
+			return true if File.exists? @dest
+
+			# Or if the .rbcli file exists anywhere in the tree, we know that we are in a subdirectory of a project
+			Project::find_root(@dest)
+		end
 	end
 
 end

data/lib/rbcli-tool/{erb_renderer.rb → util.rb}

@@ -8,7 +8,7 @@ module RBCliTool
 		end
 
 		def render
-			ERB.new(File.read(@filename)).result(binding)
+			ERB.new(File.read(@filename), nil, '-').result(binding)
 		end
 	end
 
@@ -40,4 +40,9 @@ module RBCliTool
 			exit 0
 		end
 	end
+
+	def self.exit_with_error text
+		puts text
+		exit 1
+	end
 end

data/lib/rbcli/scriptwrapping/scriptwrapper.rb

@@ -1,5 +1,9 @@
 class Rbcli::Command
 	def self.extern path: nil, envvars: nil, &block
+		if path == :default
+			callerscript = caller_locations.first.absolute_path
+			path = "#{File.dirname(callerscript)}/scripts/#{File.basename(callerscript, ".*")}.sh"
+		end
 		block = nil unless block_given?
 		@extern = Rbcli::Scriptwrapper.new path, envvars, block
 	end
@@ -14,24 +18,35 @@ require 'json'
 class Rbcli::Scriptwrapper
 	def initialize path, envvars = nil, block = nil
 		@path = path
-		@envvars = envvars
+		@envvars = envvars || {}
 		@block = block
 	end
 
 	def execute params, args, global_opts, config
-		env_hash = {}
-		{
-				'__PARAMS' => params,
-				'__ARGS' => args,
-				'__GLOBAL' => global_opts,
-				'__CONFIG' => config
-		}.each do |name, hsh|
-			hsh.each do |k, v|
-				env_hash["#{name}_#{k.upcase}"] = v.to_json
-			end
-		end
+		####
+		#### The following code will flatten one level of the hashes into separate variables
+		#### It is deprecated in favor of passing along json to be parsed with JQ
+		####
+		# env_hash = {}
+		# {
+		# 		'__PARAMS' => params,
+		# 		'__ARGS' => args,
+		# 		'__GLOBAL' => global_opts,
+		# 		'__CONFIG' => config
+		# }.each do |name, hsh|
+		# 	hsh.each do |k, v|
+		# 		env_hash["#{name}_#{k.upcase}"] = v.to_json
+		# 	end
+		# end
+		# env_hash.merge!(@envvars.deep_stringify!) unless @envvars.nil?
 
-		env_hash.merge!(@envvars.deep_stringify!) unless @envvars.nil?
+		env_hash = {
+				'__RBCLI_PARAMS' => params.to_json,
+				'__RBCLI_ARGS' => args.to_json,
+				'__RBCLI_GLOBAL' => global_opts.to_json,
+				'__RBCLI_CONFIG' => config.to_json,
+				'__RBCLI_MYVARS' => @envvars.to_json
+		}
 
 		if @block
 			path = @block.call params, args, global_opts, config
@@ -39,6 +54,11 @@ class Rbcli::Scriptwrapper
 			path = @path
 		end
 
+		# IO.popen(env_hash, path) do |io|
+		# 	while (line = io.gets) do
+		# 		puts line
+		# 	end
+		# end
 		system(env_hash, path)
 	end
 

data/lib/rbcli/version.rb

@@ -1,3 +1,3 @@
 module Rbcli
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/skeletons/project/application/commands/command.erb

@@ -0,0 +1,26 @@
+#########################
+## Command Declaration ##
+#########################
+# With rbcli, commands are declared by subclassing
+# from Rbcli::Command. The name of the class will be
+# the command that is available to the user.
+#########################
+class <%= @vars[:name].capitalize %> < Rbcli::Command                                                          # Declare a new command by subclassing Rbcli::Command
+	description '<%= @vars[:description] %>'                                         # (Required) Short description for the global help
+	usage '<%= @vars[:usage_text] %>'                           # (Required) Long description for the command-specific help
+	parameter :force, 'Force testing', type: :boolean, default: false, required: false # (Optional, Multiple) Add a command-specific CLI parameter. Can be called multiple times
+
+	config_default :myopt2, description: 'My Option #2', default: 'Default Value Here'           # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config.
+	# Alternatively, you can simply create a yaml file in the `default_user_configs` directory in your project that specifies the default values of all options
+
+	action do |params, args, global_opts, config|                                        # (Required) Block to execute if the command is called.
+		Rbcli::log.info { 'These logs can go to STDERR, STDOUT, or a file' }                       # Example log. Interface is identical to Ruby's logger
+		puts "\nArgs:\n#{args}"                    # Arguments that came after the command on the CLI (i.e.: `mytool test bar baz` will yield args=['bar', 'baz'])
+		puts "Params:\n#{params}"                  # Parameters, as described through the option statements above
+		puts "Global opts:\n#{global_opts}"        # Global Parameters, as descirbed in the Configurate section
+		puts "Config:\n#{config}"                  # Config file values
+		puts "LocalState:\n#{Rbcli.local_state}"   # Local persistent state storage (when available) -- if unsure use Rbcli.local_state.nil?
+		puts "RemoteState:\n#{Rbcli.remote_state}" # Remote persistent state storage (when available) -- if unsure use Rbcli.remote_state.nil?
+		puts "\nDone!!!"
+	end
+end

data/skeletons/project/application/commands/script.erb

@@ -0,0 +1,24 @@
+#########################
+## Command Declaration ##
+#########################
+# With rbcli, commands are declared by subclassing
+# from Rbcli::Command. The name of the class will be
+# the command that is available to the user.
+#########################
+class <%= @vars[:name].capitalize %> < Rbcli::Command                                                          # Declare a new command by subclassing Rbcli::Command
+	description '<%= @vars[:description] %>'                                         # (Required) Short description for the global help
+	usage '<%= @vars[:usage_text] %>'                           # (Required) Long description for the command-specific help
+	parameter :force, 'Force testing', type: :boolean, default: false, required: false # (Optional, Multiple) Add a command-specific CLI parameter. Can be called multiple times
+
+	config_default :myopt2, description: 'Testing this again', default: true           # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config.
+	# Alternatively, you can simply create a yaml file in the `default_user_configs` directory in your project
+
+<% if @vars[:no_script] -%>
+	extern path: 'path/to/application', envvars: {MYVAR: 'some_value'}                               # (Required) Runs a given application, with optional environment variables, when the user runs the command.
+	#extern envvars: {MY_OTHER_VAR: 'another_value'} do |params, args, global_opts, config|          # Alternate usage. Supplying a block instead of a path allows us to modify the command based on the arguments and configuration supplied by the user. This allows passing config settings as command line arguments to external applications. The block must return a string, which is the command to be executed.
+	#	"echo 'Forcing something: #{params[:force].to_s}'"
+	#end
+<% else -%>
+	extern path: :default                                                              # (Required): Do not edit this line. Do delete it if you wish to manually specify a script path and set environment variables.
+<% end -%>
+end

data/skeletons/project/application/commands/scripts/script.sh

@@ -1,23 +1,55 @@
 #!/usr/bin/env bash
-
+#
 ###
-# This is the RBCli script for the command {{**CMDNAME**}}
+# This is the RBCli script for the command `<%= @vars[:name] %>`
 ###
 #
-# You can find RBCli's params, args, global_opts, and config through environment
-# variables. They are passed in the formats:
+# You can access RBCli's variables via the `rbcli` command, which is imported by this line:
+source $(echo $(cd "$(dirname $(gem which rbcli))/../lib-sh" && pwd)/lib-rbcli.sh)
+#
+# The `rbcli` function is actually a wrapper around `jq` (https://stedolan.github.io/jq/). It can automatically
+# jq on users' machines if running Linux or OSX, and users have sudo access. If not, users must install it manually.
+# This is because behind the scenes, RBCli passes in the variable data by populating evironment variables with JSON.
+#
+# You can view the entire JSON structures with:
+#
+#    rbcli params
+#    rbcli args
+#    rbcli global_opts
+#    rbcli config
+#    rbcli myvars
+#
+# And to access specific data within that json, you can add some jq syntax as shown below. The first two examples show
+# how to get data from a nested hash, and the last example shows how to select an item from an array.
 #
-#   __PARAMS_<param_name>
-#   __ARGS_<arg_name>
-#   __GOBAL <global_opt_name>
-#   __CONFIG <config_name>
+#     echo "Log Level:  $(rbcli config .logger.log_level)"
+#     echo "Log Target: $(rbcli config .logger.log_target)"
+#     echo "First Argument (if passed): $(rbcli args .[0])"
 #
-# If any of the options given had nested values in your RBCli application they
-# will be passed as JSON. You can parse them using jq ( https://stedolan.github.io/jq/ )
+# If you wish to parse the variables manually and remove the dependency on JQ, you can comment out the line above
+# and access these variables directly:
 #
-# If you specified any environment variables to be set manually, they will be found unmodified.
+#    __RBCLI_PARAMS
+#    __RBCLI_ARGS
+#    __RBCLI_GLOBAL
+#    __RBCLI_CONFIG
+#    __RBCLI_MYVARS
 #
 ###
 #
 
-env | grep "^__PARAMS\|^__ARGS\|^__GLOBAL\|^__CONFIG"
+echo "------Params------"
+rbcli params
+echo "------Args------"
+rbcli args
+echo "------Global Opts------"
+rbcli global_opts
+echo "------Config------"
+rbcli config
+echo "------MyVars------"
+rbcli myvars
+echo ""
+echo "Usage Examples:"
+echo "Log Level:  $(rbcli config .logger.log_level)"
+echo "Log Target: $(rbcli config .logger.log_target)"
+echo "First Argument (if passed): $(rbcli args .[0])"

data/skeletons/project/hooks/default_action.rb

@@ -10,7 +10,7 @@ Rbcli::Configurate.me do
 	# If not present, the help is shown (same as -h)
 
 	default_action do |opts|
-		puts "Hello, #{opts[:name]}."
+		puts "Hello, sir."
 		puts "To see the help, use -h"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbcli
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Andrew Khoury
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-12 00:00:00.000000000 Z
+date: 2018-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -172,10 +172,12 @@ files:
 - examples/myscript.sh
 - examples/mytool
 - exe/rbcli
+- lib-sh/lib-rbcli.sh
 - lib/rbcli-tool.rb
-- lib/rbcli-tool/erb_renderer.rb
+- lib/rbcli-tool/generators.rb
 - lib/rbcli-tool/mdless_fix.rb
 - lib/rbcli-tool/project.rb
+- lib/rbcli-tool/util.rb
 - lib/rbcli.rb
 - lib/rbcli/autoupdate/autoupdate.rb
 - lib/rbcli/autoupdate/gem_updater.rb
@@ -206,7 +208,8 @@ files:
 - skeletons/project/Gemfile
 - skeletons/project/README.md
 - skeletons/project/Rakefile
-- skeletons/project/application/commands/command.rb
+- skeletons/project/application/commands/command.erb
+- skeletons/project/application/commands/script.erb
 - skeletons/project/application/commands/scripts/script.sh
 - skeletons/project/application/options.rb
 - skeletons/project/config/autoupdate.rb

data/skeletons/project/application/commands/command.rb

@@ -1,31 +0,0 @@
-#########################
-## Command Declaration ##
-#########################
-# With rbcli, commands are declared by subclassing
-# from Rbcli::Command. The name of the class will be
-# the command that is available to the user.
-#########################
-class Test < Rbcli::Command                                                          # Declare a new command by subclassing Rbcli::Command
-	description 'This is a short description.'                                         # (Required) Short description for the global help
-	usage 'This is some really long usage text description!'                           # (Required) Long description for the command-specific help
-	parameter :force, 'Force testing', type: :boolean, default: false, required: false # (Optional, Multiple) Add a command-specific CLI parameter. Can be called multiple times
-
-	config_defaults 'defaults.yml'                                                     # (Optional, Multiple) Load a YAML file as part of the default config. This can be called multiple times, and the YAML files will be merged. User config is generated from these
-	config_default :myopt2, description: 'Testing this again', default: true           # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config
-
-	extern path: 'env | grep "^__PARAMS\|^__ARGS\|^__GLOBAL\|^__CONFIG"', envvars: {MYVAR: 'some_value'}     # (Required unless `action` defined) Runs a given application, with optional environment variables, when the user runs the command.
-	extern envvars: {MY_OTHER_VAR: 'another_value'} do |params, args, global_opts, config|                   # Alternate usage. Supplying a block instead of a path allows us to modify the command based on the arguments and configuration supplied by the user.
-		"echo #{params[:force].to_s}__YESSS!!!"
-	end
-
-	action do |params, args, global_opts, config|                                        # (Required unless `extern` defined) Block to execute if the command is called.
-		Rbcli::log.info { 'These logs can go to STDERR, STDOUT, or a file' }                       # Example log. Interface is identical to Ruby's logger
-		puts "\nArgs:\n#{args}"                    # Arguments that came after the command on the CLI (i.e.: `mytool test bar baz` will yield args=['bar', 'baz'])
-		puts "Params:\n#{params}"                  # Parameters, as described through the option statements above
-		puts "Global opts:\n#{global_opts}"        # Global Parameters, as descirbed in the Configurate section
-		puts "Config:\n#{config}"                  # Config file values
-		puts "LocalState:\n#{Rbcli.local_state}"   # Local persistent state storage (when available) -- if unsure use Rbcli.local_state.nil?
-		puts "RemoteState:\n#{Rbcli.remote_state}" # Remote persistent state storage (when available) -- if unsure use Rbcli.remote_state.nil?
-		puts "\nDone!!!"
-	end
-end