rbcli 0.1.7 → 0.1.8

data/lib/rbcli-tool/mdless_fix.rb

@@ -0,0 +1,386 @@
+require 'mdless'
+
+def class_exists?(class_name)
+	klass = Module.const_get(class_name)
+	return klass.is_a?(Class)
+rescue NameError
+	return false
+end
+
+if class_exists? 'Encoding'
+	Encoding.default_external = Encoding::UTF_8 if Encoding.respond_to?('default_external')
+	Encoding.default_internal = Encoding::UTF_8 if Encoding.respond_to?('default_internal')
+end
+
+module CLIMarkdown
+	class Converter
+		def convert_markdown(input)
+			@headers = get_headers(input)
+			# yaml/MMD headers
+			in_yaml = false
+			if input.split("\n")[0] =~ /(?i-m)^---[ \t]*?(\n|$)/
+				@log.info("Found YAML")
+				# YAML
+				in_yaml = true
+				input.sub!(/(?i-m)^---[ \t]*\n([\s\S]*?)\n[\-.]{3}[ \t]*\n/) do |yaml|
+					m = Regexp.last_match
+
+					@log.warn("Processing YAML Header")
+					m[0].split(/\n/).map {|line|
+						if line =~ /^[\-.]{3}\s*$/
+							line = c([:d,:black,:on_black]) + "% " + c([:d,:black,:on_black]) + line
+						else
+							line.sub!(/^(.*?:)[ \t]+(\S)/, '\1 \2')
+							line = c([:d,:black,:on_black]) + "% " + c([:d,:white]) + line
+						end
+						if @cols - line.uncolor.size > 0
+							line += " "*(@cols-line.uncolor.size)
+						end
+					}.join("\n") + "#{xc}\n"
+				end
+			end
+
+			if !in_yaml && input.gsub(/\n/,' ') =~ /(?i-m)^\w.+:\s+\S+ /
+				@log.info("Found MMD Headers")
+				input.sub!(/(?i-m)^([\S ]+:[\s\S]*?)+(?=\n\n)/) do |mmd|
+					puts mmd
+					mmd.split(/\n/).map {|line|
+						line.sub!(/^(.*?:)[ \t]+(\S)/, '\1 \2')
+						line = c([:d,:black,:on_black]) + "% " + c([:d,:white,:on_black]) + line
+						if @cols - line.uncolor.size > 0
+							line += " "*(@cols - line.uncolor.size)
+						end
+					}.join("\n") + " "*@cols + "#{xc}\n"
+				end
+
+			end
+
+
+			# Gather reference links
+			input.gsub!(/^\s{,3}(?<![\e*])\[\b(.+)\b\]: +(.+)/) do |m|
+				match = Regexp.last_match
+				@ref_links[match[1]] = match[2]
+				''
+			end
+
+			# Gather footnotes (non-inline)
+			input.gsub!(/^ {,3}(?<!\*)(?:\e\[[\d;]+m)*\[(?:\e\[[\d;]+m)*\^(?:\e\[[\d;]+m)*\b(.+)\b(?:\e\[[\d;]+m)*\]: *(.*?)\n/) do |m|
+				match = Regexp.last_match
+				@footnotes[match[1].uncolor] = match[2].uncolor
+				''
+			end
+
+			if @options[:section]
+				in_section = false
+				top_level = 1
+				new_content = []
+
+				input.split(/\n/).each {|graf|
+					if graf =~ /^(#+) *(.*?)( *#+)?$/
+						level = $1.length
+						title = $2
+
+						if in_section
+							if level >= top_level
+								new_content.push(graf)
+							else
+								in_section = false
+								break
+							end
+						elsif title.downcase == "#{@headers[@options[:section] - 1][1].downcase}"
+							in_section = true
+							top_level = level + 1
+							new_content.push(graf)
+						else
+							next
+						end
+					elsif in_section
+						new_content.push(graf)
+					end
+				}
+
+				input = new_content.join("\n")
+			end
+
+			h_adjust = highest_header(input) - 1
+			input.gsub!(/^(#+)/) do |m|
+				match = Regexp.last_match
+				"#" * (match[1].length - h_adjust)
+			end
+
+			input.gsub!(/(?i-m)([`~]{3,})([\s\S]*?)\n([\s\S]*?)\1/ ) do |cb|
+				m = Regexp.last_match
+				leader = m[2] ? m[2].upcase + ":" : 'CODE:'
+				leader += xc
+
+				if exec_available('pygmentize')
+					lexer = m[2].nil? ? '-g' : "-l #{m[2]}"
+					begin
+						hilite, s = Open3.capture2(%Q{pygmentize #{lexer} 2> /dev/null}, :stdin_data=>m[3])
+
+						if s.success?
+							hilite = hilite.split(/\n/).map{|l| "#{c([:x,:black])}~ #{xc}" + l}.join("\n")
+						end
+					rescue => e
+						@log.error(e)
+						hilite = m[0]
+					end
+
+				else
+
+					hilite = m[3].split(/\n/).map{|l|
+						new_code_line = l.gsub(/\t/,'    ')
+						orig_length = new_code_line.size + 3
+						new_code_line.gsub!(/ /,"#{c([:x,:white,:on_black])} ")
+						"#{c([:x,:black])}~ #{c([:x,:white,:on_black])} " + new_code_line + c([:x,:white,:on_black]) + xc
+					}.join("\n")
+				end
+				"#{c([:x,:magenta])}#{leader}\n#{hilite}#{xc}"
+			end
+
+			# remove empty links
+			input.gsub!(/\[(.*?)\]\(\s*?\)/, '\1')
+			input.gsub!(/\[(.*?)\]\[\]/, '[\1][\1]')
+
+			lines = input.split(/\n/)
+
+			# previous_indent = 0
+
+			lines.map!.with_index do |aLine, i|
+				line = aLine.dup
+				clean_line = line.dup.uncolor
+
+
+				if clean_line.uncolor =~ /(^[%~])/ # || clean_line.uncolor =~ /^( {4,}|\t+)/
+					## TODO: find indented code blocks and prevent highlighting
+					## Needs to miss block indented 1 level in lists
+					## Needs to catch lists in code
+					## Needs to avoid within fenced code blocks
+					# if line =~ /^([ \t]+)([^*-+]+)/
+					#   indent = $1.gsub(/\t/, "    ").size
+					#   if indent >= previous_indent
+					#     line = "~" + line
+					#   end
+					#   p [indent, previous_indent]
+					#   previous_indent = indent
+					# end
+				else
+					# Headlines
+					line.gsub!(/^(#+) *(.*?)(\s*#+)?\s*$/) do |match|
+						m = Regexp.last_match
+						pad = ""
+						ansi = ''
+						case m[1].length
+						when 1
+							ansi = c([:b, :black, :on_intense_white])
+							pad = c([:b,:white])
+							pad += m[2].length + 2 > @cols ? "*"*m[2].length : "*"*(@cols - (m[2].length + 2))
+						when 2
+							ansi = c([:b, :green, :on_black])
+							pad = c([:b,:black])
+							pad += m[2].length + 2 > @cols ? "-"*m[2].length : "-"*(@cols - (m[2].length + 2))
+						when 3
+							ansi = c([:u, :b, :yellow])
+						when 4
+							ansi = c([:x, :u, :yellow])
+						else
+							ansi = c([:b, :white])
+						end
+
+						"\n#{xc}#{ansi}#{m[2]} #{pad}#{xc}\n"
+					end
+
+					# place footnotes under paragraphs that reference them
+					if line =~ /\[(?:\e\[[\d;]+m)*\^(?:\e\[[\d;]+m)*(\S+)(?:\e\[[\d;]+m)*\]/
+						key = $1.uncolor
+						if @footnotes.key? key
+							line += "\n\n#{c([:b,:black,:on_black])}[#{c([:b,:cyan,:on_black])}^#{c([:x,:yellow,:on_black])}#{key}#{c([:b,:black,:on_black])}]: #{c([:u,:white,:on_black])}#{@footnotes[key]}#{xc}"
+							@footnotes.delete(key)
+						end
+					end
+
+					# color footnote references
+					line.gsub!(/\[\^(\S+)\]/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match, true)
+						counter = i
+						while last.nil? && counter > 0
+							counter -= 1
+							find_color(lines[counter])
+						end
+						"#{c([:b,:black])}[#{c([:b,:yellow])}^#{c([:x,:yellow])}#{match[1]}#{c([:b,:black])}]" + (last ? last : xc)
+					end
+
+					# blockquotes
+					line.gsub!(/^(\s*>)+( .*?)?$/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match, true)
+						counter = i
+						while last.nil? && counter > 0
+							counter -= 1
+							find_color(lines[counter])
+						end
+						"#{c([:b,:black])}#{match[1]}#{c([:x,:magenta])} #{match[2]}" + (last ? last : xc)
+					end
+
+					# make reference links inline
+					line.gsub!(/(?<![\e*])\[(\b.*?\b)?\]\[(\b.+?\b)?\]/) do |m|
+						match = Regexp.last_match
+						title = match[2] || ''
+						text = match[1] || ''
+						if match[2] && @ref_links.key?(title.downcase)
+							"[#{text}](#{@ref_links[title]})"
+						elsif match[1] && @ref_links.key?(text.downcase)
+							"[#{text}](#{@ref_links[text]})"
+						else
+							if input.match(/^#+\s*#{Regexp.escape(text)}/i)
+								"[#{text}](##{text})"
+							else
+								match[1]
+							end
+						end
+					end
+
+					# color inline links
+					line.gsub!(/(?<![\e*!])\[(\S.*?\S)\]\((\S.+?\S)\)/) do |m|
+						match = Regexp.last_match
+						color_link(match.pre_match, match[1], match[2])
+					end
+
+
+
+					# inline code
+					line.gsub!(/`(.*?)`/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match, true)
+						"#{c([:b,:black])}`#{c([:b,:white])}#{match[1]}#{c([:b,:black])}`" + (last ? last : xc)
+					end
+
+					# horizontal rules
+					line.gsub!(/^ {,3}([\-*] ?){3,}$/) do |m|
+						c([:x,:black]) + '_'*@cols + xc
+					end
+
+					# bold, bold/italic
+					line.gsub!(/(^|\s)[\*_]{2,3}([^\*_\s][^\*_]+?[^\*_\s])[\*_]{2,3}/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match, true)
+						counter = i
+						while last.nil? && counter > 0
+							counter -= 1
+							find_color(lines[counter])
+						end
+						"#{match[1]}#{c([:b])}#{match[2]}" + (last ? last : xc)
+					end
+
+					# italic
+					line.gsub!(/(^|\s)[\*_]([^\*_\s][^\*_]+?[^\*_\s])[\*_]/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match, true)
+						counter = i
+						while last.nil? && counter > 0
+							counter -= 1
+							find_color(lines[counter])
+						end
+						"#{match[1]}#{c([:u])}#{match[2]}" + (last ? last : xc)
+					end
+
+					# equations
+					line.gsub!(/((\\\\\[)(.*?)(\\\\\])|(\\\\\()(.*?)(\\\\\)))/) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match)
+						if match[2]
+							brackets = [match[2], match[4]]
+							equat = match[3]
+						else
+							brackets = [match[5], match[7]]
+							equat = match[6]
+						end
+						"#{c([:b, :black])}#{brackets[0]}#{xc}#{c([:b,:blue])}#{equat}#{c([:b, :black])}#{brackets[1]}" + (last ? last : xc)
+					end
+
+					# list items
+					# TODO: Fix ordered list numbering, pad numbers based on total number of list items
+					line.gsub!(/^(\s*)([*\-+]|\d+\.) /) do |m|
+						match = Regexp.last_match
+						last = find_color(match.pre_match)
+						indent = match[1] || ''
+						"#{indent}#{c([:d, :red])}#{match[2]} " + (last ? last : xc)
+					end
+
+					# definition lists
+					line.gsub!(/^(:\s*)(.*?)/) do |m|
+						match = Regexp.last_match
+						"#{c([:d, :red])}#{match[1]} #{c([:b, :white])}#{match[2]}#{xc}"
+					end
+
+					# misc html
+					line.gsub!(/<br\/?>/, "\n")
+					line.gsub!(/(?i-m)((<\/?)(\w+[\s\S]*?)(>))/) do |tag|
+						match = Regexp.last_match
+						last = find_color(match.pre_match)
+						"#{c([:d,:black])}#{match[2]}#{c([:b,:black])}#{match[3]}#{c([:d,:black])}#{match[4]}" + (last ? last : xc)
+					end
+				end
+
+				line
+			end
+
+			input = lines.join("\n")
+
+			# images
+			input.gsub!(/^(.*?)!\[(.*)?\]\((.*?\.(?:png|gif|jpg))( +.*)?\)/) do |m|
+				match = Regexp.last_match
+				if match[1].uncolor =~ /^( {4,}|\t)+/
+					match[0]
+				else
+					tail = match[4].nil? ? '' : " "+match[4].strip
+					result = nil
+					if exec_available('imgcat') && @options[:local_images]
+						if match[3]
+							img_path = match[3]
+							if img_path =~ /^http/ && @options[:remote_images]
+								begin
+									res, s = Open3.capture2(%Q{curl -sS "#{img_path}" 2> /dev/null | imgcat})
+
+									if s.success?
+										pre = match[2].size > 0 ? "    #{c([:d,:blue])}[#{match[2].strip}]\n" : ''
+										post = tail.size > 0 ? "\n    #{c([:b,:blue])}-- #{tail} --" : ''
+										result = pre + res + post
+									end
+								rescue => e
+									@log.error(e)
+								end
+							else
+								if img_path =~ /^[~\/]/
+									img_path = File.expand_path(img_path)
+								elsif @file
+									base = File.expand_path(File.dirname(@file))
+									img_path = File.join(base,img_path)
+								end
+								if File.exists?(img_path)
+									pre = match[2].size > 0 ? "    #{c([:d,:blue])}[#{match[2].strip}]\n" : ''
+									post = tail.size > 0 ? "\n    #{c([:b,:blue])}-- #{tail} --" : ''
+									img = %x{imgcat "#{img_path}"}
+									result = pre + img + post
+								end
+							end
+						end
+					end
+					if result.nil?
+						match[1] + color_image(match.pre_match, match[2], match[3] + tail) + xc
+					else
+						match[1] + result + xc
+					end
+				end
+			end
+
+			@footnotes.each {|t, v|
+				input += "\n\n#{c([:b,:black,:on_black])}[#{c([:b,:yellow,:on_black])}^#{c([:x,:yellow,:on_black])}#{t}#{c([:b,:black,:on_black])}]: #{c([:u,:white,:on_black])}#{v}#{xc}"
+			}
+
+			@output += input
+
+		end
+	end
+end

data/lib/rbcli-tool/project.rb

@@ -0,0 +1,87 @@
+module RBCliTool
+	class Project
+
+		def initialize path, template_vars = {}
+			@skelpath = "#{File.dirname(__FILE__)}/../../skeletons/project"
+			@minipath = "#{File.dirname(__FILE__)}/../../skeletons/mini/executable"
+			@micropath = "#{File.dirname(__FILE__)}/../../skeletons/micro/executable"
+
+			@dest = path
+			@template_vars = template_vars
+		end
+
+		def create force = false
+			return false if project_exists? and not force
+			src = @skelpath
+
+			# Create Top Level Folder (TLF)
+			FileUtils.mkdir_p @dest
+
+			# Create project structure
+			%w(
+				application/commands
+				application/commands/scripts
+				config
+				default_user_configs
+				exe
+				hooks
+				spec
+			).each do |folder|
+				FileUtils.mkdir_p "#{@dest}/#{folder}"
+				FileUtils.touch "#{@dest}/#{folder}/.keep"
+			end
+
+			# Create executable
+			RBCliTool.cp_file "#{src}/exe/executable", "#{@dest}/exe/#{@template_vars[:cmdname]}", @template_vars
+
+			# Create files for Gem package
+			Dir.entries(src).each do |file|
+				next if File.directory? "#{src}/#{file}"
+				RBCliTool.cp_file "#{src}/#{file}", "#{@dest}/", @template_vars
+			end
+
+			# Create default config
+			Dir.glob "#{src}/config/*.rb" do |file|
+				RBCliTool.cp_file file, "#{@dest}/config/", @template_vars
+			end
+
+			# Create application options
+			RBCliTool.cp_file "#{src}/application/options.rb", "#{@dest}/application/options.rb", @template_vars
+
+			true
+		end
+
+		def create_mini force = false
+			return false if project_exists? and not force
+			RBCliTool.cp_file @minipath, @dest, @template_vars
+		end
+
+		def create_micro force = false
+			return false if project_exists? and not force
+			RBCliTool.cp_file @micropath, @dest, @template_vars
+		end
+
+		def exists?
+			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
+			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
+	end
+
+end

data/lib/rbcli-tool.rb

@@ -0,0 +1,16 @@
+###########
+## RBCLI ##
+###########
+#
+# This file loads the Rbcli CLI Tool components.
+#
+###########
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+module RBCliTool end
+
+require 'rbcli-tool/mdless_fix'
+require 'rbcli-tool/erb_renderer'
+require 'rbcli-tool/project'

data/lib/rbcli.rb

@@ -12,7 +12,7 @@ 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/version'
 
 # UTILS
 require 'rbcli/util/hash_deep_symbolize'
@@ -26,22 +26,23 @@ require 'rbcli/logging/logging'
 
 
 # STATE TOOLS
-require "rbcli/stateful_systems/configuratestorage"
-require "rbcli/stateful_systems/state_storage"
-require "rbcli/stateful_systems/storagetypes/localstate"
-require "rbcli/stateful_systems/storagetypes/remotestate_dynamodb"
+require 'rbcli/stateful_systems/configuratestorage'
+require 'rbcli/stateful_systems/state_storage'
+require 'rbcli/stateful_systems/storagetypes/localstate'
+require 'rbcli/stateful_systems/storagetypes/remotestate_dynamodb'
 # END STATE TOOLS
 
 # AUTOUPDATE
-require "rbcli/autoupdate/autoupdate"
+require 'rbcli/autoupdate/autoupdate'
 # END AUTOUPDATE
 
 # SCRIPT WRAPPER
-require "rbcli/scriptwrapping/scriptwrapper"
+require 'rbcli/scriptwrapping/scriptwrapper'
 # END SCRIPT WRAPPER
 
 # CORE
-require "rbcli/configuration/configurate"
-require "rbcli/engine/command"
-require "rbcli/engine/parser"
+require 'rbcli/configuration/configurate'
+require 'rbcli/engine/load_project'
+require 'rbcli/engine/command'
+require 'rbcli/engine/parser'
 # END CORE

data/rbcli.gemspec

@@ -44,6 +44,7 @@ Gem::Specification.new do |spec|
 	spec.add_dependency 'macaddr', '~> 1.7'
 	spec.add_dependency 'rufus-scheduler', '~> 3.5'
 	spec.add_dependency 'octokit', '~> 4.9'
+	spec.add_dependency 'mdless', '~> 0.0'
 
 	#spec.add_dependency 'trollop', '~> 2.1'
 end

data/skeletons/micro/executable

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+#########################################################
+### <%= @vars[:cmdname] %>
+#######
+## This is the main executable for <%= @vars[:cmdname] %>.
+## It's job is to load and execute the application.
+#########################################################
+
+require 'rbcli'
+
+#########################
+## Configuration Block ##
+#########################
+Rbcli::Configurate.me do
+	## Script Name -- (Required) -- This line identifies the tool's executable on the command line.
+	scriptname __FILE__.split('/')[-1]
+
+	## Version Number -- (Required)
+	version '0.1.0'
+
+	## Description -- (Requierd) -- A description that will appear when the user looks at the help with -h. This can be as long as needed.
+	description  %q{<%= @vars[:description] %>}
+
+
+	## Log Target -- (Optional) -- Set the target for logs.
+	log_target nil
+
+	## Log Level -- (Optional) -- Set the default log_level for users.
+	log_level nil
+
+
+	## Config Userfile -- (Optional) -- Set location of user's config file.
+	config_userfile '~/.<%= @vars[:cmdname] %>', merge_defaults: true, required: false
+
+	## Config Defaults -- (Optional, Multiple) -- Load a YAML file as part of the default config.
+	#config_defaults 'defaults.yml'
+
+	## Config Default -- (Optional, Multiple) -- Specify an individual configuration parameter and set a default value.
+	config_default :myopt, description: 'Testing this', default: true
+
+
+	## Autoupdate, Github -- (Optional) --  Check for updates to this application at a GitHub repo.
+	#autoupdate github_repo: '<your_user>/<your_repo>', access_token: nil, enterprise_hostname: nil, force_update: false
+
+	## Autoupdate, Rubygems.org -- (Optional) -- Check for updates to this application on Rubygems.org
+	#autoupdate gem: '<your_gem>', force_update: false
+
+
+	## Option -- (Optional, Multiple) -- Add a global CLI Option
+	option :name, 'Give me your name', type: :string, default: 'Foo', required: false, permitted: ['Jack', 'Jill']
+
+
+	## Default Action -- (Optional) -- The default code to execute when no subcommand is given.
+	default_action do |opts|
+		puts "Hello, #{opts[:name]}."
+		puts "To see the help, use -h"
+	end
+
+	## Pre-Execution Hook -- (Optional) -- Allows providing a block of code that runs _before_ all commands
+	# pre_hook do |opts|
+	# 	puts 'This is a pre-command hook. It executes before the command.'
+	# end
+
+	## Post-Execution Hook -- (Optional) -- Allows providing a block of code that runs _after_ all commands
+	# post_hook do |opts|
+	# 	puts 'This is a post-command hook. It executes after the command.'
+	# end
+
+	## First-Run Hook -- (Optional) -- Allows providing a block of code that executes the first time that the application is run on a given system.
+	# first_run halt_after_running: false do
+	# 	puts "This is the first time the mytool command is run! Don't forget to generate a config file with the `-g` option before continuing."
+	# end
+end
+
+###############################
+## State Configuration Block ##
+###############################
+Rbcli::Configurate.storage do
+	###
+	# Local State Storage
+	###
+
+	## Local State -- (Optional) -- Creates a hash that is automatically saved to a file locally for state persistance. It is accessible to all commands at  Rbcli.localstate[:yourkeyhere]
+	#local_state '/var/mytool/localstate', force_creation: true, halt_on_error: true
+
+
+	## Remote State -- (Optional) -- Creates a hash that is automatically saved to a DynamoDB table. It is recommended to keep halt_on_error=true when using a shared state. Locking can be one of (:manual :auto :none).
+	#remote_state_dynamodb table_name: 'mytable', region: 'us-east-1', force_creation: true, halt_on_error: true, locking: :auto
+end
+
+#########################
+## Command Declaration ##
+#########################
+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
+
+#####################
+## Parse Statement ##
+#####################
+Rbcli.parse       # Parse CLI and execute