rbcli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f693140670cf6500039ed8201c5be45e2dccde591ef47b83687d1bd80a638b64
+  data.tar.gz: bb386ad56f5358f6cdd25d6fedba51c872084ecc705a92b1fad7bae969466429
+SHA512:
+  metadata.gz: 56089e16775977cad480e6575cb1852c2cddb0228e6c7e35f2aff7b813e13fa6daa339822f9981e89fba78823b01de6e0519eb9e618604fd0af925400b7cbbaf
+  data.tar.gz: 52f1cf70c8dcc080216f2ef3b522664752ffc4935cd1e0e75af16b7bc34fc1c79686a3ed5b475cf16280d4d0206d40c751009cccf523aac925e6de91ca442ac2

data/.gitignore

@@ -0,0 +1,60 @@
+# Created by https://www.gitignore.io/api/git,ruby
+
+### Git ###
+*.orig
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+
+# End of https://www.gitignore.io/api/git,ruby

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at akhoury@live.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rbcli.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    rbcli (0.1.0)
+      colorize (~> 0.8)
+      deep_merge (~> 1.2)
+      trollop (~> 2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    deep_merge (1.2.1)
+    minitest (5.11.3)
+    rake (10.5.0)
+    trollop (2.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  rbcli!
+
+BUNDLED WITH
+   1.16.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Andrew Khoury
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,207 @@
+# RBCli
+
+RBCli is a framework to quickly develop advanced command-line tools in Ruby. It has been written from the ground up with the needs of the modern technologist in mind, designed to make advanced CLI tool development as painless as possible.
+
+Some of its key features include:
+
+* __Simple DSL Interface__: To cut down on the amount of code that needs to be written, RBCli has a DSL that is designed to cut to the chase. This makes the work a lot less tedious.
+  
+* __Multiple Levels of Parameters and Arguments__: Forget about writing parsers for command-line options, or about having to differentiate between parameters and arguments. All of that work is taken care of.
+
+* __Config File Generation__: Easily piece together a default configuration even with declarations in different parts of the code. Then the user can generate their own configuration, and it gets stored in whatever location you'd like.
+
+* __Logging__: Keep track of all instances of your tool through logging. Logs can go to STDOUT, STDERR, or a given file, making them compatible with log aggregators such as Splunk, Logstash, and many others.
+
+
+## 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`.
+
+## The Basics
+
+RBCli enforces a general command-line structure:
+
+```
+toolname [options] command [parameters] [lineitem]
+```
+
+* __Options__ are command line parameters such as `-f`, or `--force`. These are available globally to every command. You can create your own, but several options are already built-in:
+	* `-c <filename> / --config-file=<filename>` allows specifying a config file manually
+	* `-g / --generate-config` generates a config file by writing out the defaults to a YAML file (location is configurable, more on that below)
+	* `-v / --version` shows the version`
+	* `-h / --help` shows the help
+* __Command__ represents the subcommands that you will create, such as `test` or `apply`
+* __Parameters__ are the same as options, but only apply to the specific subcommand being executed. In this case only the `-h / --help` parameter is provided.
+* __Lineitems__ are strings that don't begin with a '-', and are passed to the command's code. These can be used as subcommands or additional parameters for your code. 
+
+So a valid command could look something like these:
+
+```shell
+mytool -n load --filename=foo.txt
+mytool parse foo.txt
+mytool show -l
+```
+
+Note that all options and parameters will have both a short and long version of the parameter available for use.
+
+## Getting Started
+
+Creating a new skeleton command is as easy as running `rbcli init <filename>`. It will have three key items:
+
+* The configuration
+* A command declaration
+* The parse command
+
+
+### Configuration
+
+```ruby
+require 'rbcli'
+
+Rbcli::configurate do
+	scriptname __FILE__.split('/')[-1]                                     # (Required) This line identifies the tool's executable. You can change it if needed, but this should work for most cases.
+	version '0.1.0'                                                        # (Required) The version number
+	description 'This is my test CLI tool.'                                # (Requierd) A description that will appear when the user looks at the help with -h. This can be as long as needed.
+	
+	log_level :info                                                        # (Optional) Set the default log_level for users. 0-5, or DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+  log_target 'stderr'                                                    # (Optional) Set the target for logs. Valid values are STDOUT, STDERR, or a file path (as strings)
+
+	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.
+	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 :myopt, description: 'Testing this', value: true        # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config
+
+	option :name, 'Give me your name', type: :string, default: 'Stranger'  # (Optional, Multiple) Add a global CLI parameter. Supported types are :string, :boolean, :integer, :float, :date, and :io. Can be called multiple times.
+
+	default_action do |opts|                                               # (Optional) The default code to execute when no subcommand is given. If not present, the help is shown (same as -h)
+		puts "Hello, #{opts[:name]}."
+		puts "To see the help, use -h"
+	end
+
+	pre_hook do |opts|                                                     # (Optional) Allows providing a block of code that runs before any command
+		puts 'This is a pre-command hook. It executes before the command.'
+	end
+
+	post_hook do |opts|                                                    # (Optional) Allows providing a block of code that runs after any command
+		puts 'This is a post-command hook. It executes after the command.'
+	end
+end
+
+```
+
+### Command Declaration
+
+Commands are added by subclassing `Rbcli::Command`. There are a few parameters to set for it, which get used by the different components of Rbcli.
+
+```ruby
+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', value: true             # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config
+
+	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
+		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 "\nDone!!!"
+	end
+end
+
+```
+
+### Parse Command
+
+```ruby
+Rbcli.parse       # Parse CLI and execute
+```
+
+## Execution Chain
+
+RBCli takes actions in a specific order when `parse` is run.
+
+1. The default config is loaded
+2. The user config is loaded if present
+3. CLI is parsed for global options, which are then stored in a hash and passed on to the other parts of the code. Built-in options, however, may cause the code to branch and exit.
+4. The CLI is parsed for a command.
+	a. If no command is entered, RBCLI will check if a `default_acction` block has been provided.
+		i. If the block is defined, execute it
+		ii. Otherwise, show the help
+	b. If a command has been entered, the rest of the CLI is parsed for parameters and lineitems, and the code block for the command is called
+
+## Configuration Files
+
+RBCli has two chains to manage configuration: the __defaults chain__ and the __user chain__.
+
+### Defaults chain
+
+The defaults chain allows you to specify sane defaults for your CLI tool throughout your code. This gives you the ability to declare configuration alongside the code, and allows RBCli to generate a user config automatically given your defaults. There are two ways to set them:
+
+* YAML Files
+	* You can store your defaults in one or more YAML files and RBCli will import and combine them. Note that when generating the user config, RBCli will use the YAML text as-is, so comments are transferred as well. This allows you to write descriptions for the options directly in the file that the user can see.
+	* This is good for tools with large or complex configuration that needs user documentation written inline
+	* `config_defaults "<filename>"` in the DSL
+* DSL Statements
+	* In the DSL, you can specify options individually by providing a name, description, and default value
+	* This is good for simpler configuration, as the descriptions provided are written out as comments in the generated user config
+	* `config_default :name, description: '<description_text>', value: <default_value>` in the DSL
+	
+Users can generate configs by running `yourclitool -g`. This will generate a config file at the tool's default location specified in the DSL. A specific location can be used via the `-c` parameter. You can test how this works by running `examples/mytool -c test.yml -g`.
+ 
+### User chain
+
+The user chain has two functions: generating and loading configuration from a YAML file.
+
+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.`
+2. The location specified on the command line using the `-c <filename>` option
+	b. `yourclitool -c localfile.yml`
+
+Users can generate configs by running `yourclitool -g`. This will generate a config file at the tool's default location specified in the DSL. A specific location can be used via the `-c` parameter. You can test how this works by running `examples/mytool -c test.yml -g`.
+
+## Logging
+
+Logging with RBCli is straightforward - it looks at the config file for logging settings, and instantiates a single, globally accessible [Logger](https://ruby-doc.org/stdlib-2.4.0/libdoc/logger/rdoc/Logger.html)` object. You can access it as such:
+
+```ruby
+Rbcli::log.info { 'These logs can go to STDERR, STDOUT, or a file' }
+```
+
+Default values can be set in the configurate DSL:
+
+```ruby
+log_level :info                                                        # (Optional) Set the default log_level for users. 0-5, or DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+log_target 'stderr'                                                    # (Optional) Set the target for logs. Valid values are STDOUT, STDERR, or a file path (as strings)
+```
+
+Two configuration options will always be placed in a user's YAML file to override defaults: 
+
+```yaml
+# Log Settings
+logger:
+  log_level: warn              # 0-5, or DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+  log_target: stderr           # STDOUT, STDERR, or a file path
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine from source, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/akhoury6/rbcli. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rbcli project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/akhoury6/rbcli/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbcli"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/defaults.yml

@@ -0,0 +1,4 @@
+# Mytool custom settings
+optionA: value     # We are setting this value just because
+optionB: value2    # Same here
+optionC: value3    # You get the picture

data/examples/mytool

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'rbcli'
+
+#########################
+## Configuration Block ##
+#########################
+# This block is where rbcli is configured.
+#########################
+
+Rbcli::configurate do
+	scriptname __FILE__.split('/')[-1]                                     # (Required) This line identifies the tool's executable. You can change it if needed, but this should work for most cases.
+	version '0.1.0'                                                        # (Required) The version number
+	description 'This is my test CLI tool.'                                # (Requierd) A description that will appear when the user looks at the help with -h. This can be as long as needed.
+
+	log_level :info                                                        # (Optional) Set the default log_level for users. 0-5, or DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+	log_target 'stderr'                                                    # (Optional) Set the target for logs. Valid values are STDOUT, STDERR, or a file path (as strings)
+
+	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.
+	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 :myopt, description: 'Testing this', value: true        # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config
+
+	option :name, 'Give me your name', type: :string, default: 'Stranger'  # (Optional, Multiple) Add a global CLI parameter. Supported types are :string, :boolean, :integer, :float, :date, and :io. Can be called multiple times.
+
+	default_action do |opts|                                               # (Optional) The default code to execute when no subcommand is given. If not present, the help is shown (same as -h)
+		puts "Hello, #{opts[:name]}."
+		puts "To see the help, use -h"
+	end
+
+	pre_hook do |opts|                                                     # (Optional) Allows providing a block of code that runs before any command
+		puts 'This is a pre-command hook. It executes before the command.'
+	end
+
+	post_hook do |opts|                                                    # (Optional) Allows providing a block of code that runs after any command
+		puts 'This is a post-command hook. It executes after the command.'
+	end
+end
+
+#########################
+## 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', value: true             # (Optional, Multiple) Specify an individual configuration parameter and set a default value. These will also be included in generated user config
+
+	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
+		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 "\nDone!!!"
+	end
+end
+
+#####################
+## Parse Statement ##
+#####################
+# When this statement is called, the CLI will be
+# parsed and code executed as
+#####################
+Rbcli.parse       # Parse CLI and execute

data/exe/rbcli

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require '../lib/rbcli'
+
+Rbcli::configurate do
+	scriptname __FILE__.split('/')[-1]
+	version Rbcli::VERSION
+	description 'RBCli initialization tool'
+end
+
+class Init < Rbcli::Command
+	description 'Initialize a skeleton RBCli executable.'
+	usage 'This will generate a new file in the current folder'
+	parameter :filename, 'Name of file to generate', type: :string, required: true
+
+	action do |params, args, global_opts, config|
+		src = "#{File.dirname(__FILE__)}/../examples/mytool"
+		dest = "#{Dir.pwd}/#{params[:filename]}"
+		if File.exists? dest
+			puts "File #{params[:filename]} already exists. Please delete and try again."
+		else
+			puts "Generating file #{params[:filename]}..."
+			FileUtils.cp src, dest
+			puts "Done!"
+		end
+	end
+
+end
+
+Rbcli.parse

data/lib/rbcli/configurate.rb

@@ -0,0 +1,91 @@
+module Rbcli
+
+	@data = {
+			scriptname: nil,
+			version: nil,
+			description: nil,
+			config_userfile: 'config.yml',
+			allow_json: false,
+			options: {},
+			default_action: nil,
+			pre_hook: nil,
+			post_hook: nil
+	}
+
+	def self.configurate &block
+		@self_before_instance_eval = eval "self", block.binding
+		instance_eval &block
+	end
+
+	# def self.method_missing(method, *args, &block)
+	# 	@self_before_instance_eval.send method, *args, &block
+	# end
+
+	##
+	# DSL Functions
+	##
+	def self.scriptname name
+		@data[:scriptname] = name
+	end
+
+	def self.version vsn
+		@data[:version] = vsn
+	end
+
+	def self.description desc
+		@data[:description] = desc
+	end
+
+	def self.log_level level
+		Rbcli::Logger::save_defaults level: level
+	end
+
+	def self.log_target target
+		Rbcli::Logger::save_defaults target: target
+	end
+
+	def self.config_userfile *params
+		Rbcli::Config::set_userfile *params
+		@data[:config_userfile] = params[0]
+	end
+
+	def self.config_defaults filename
+		Rbcli::Config::add_defaults filename
+	end
+
+	def self.config_default *params
+		Rbcli::Config::add_default *params
+	end
+
+	def self.allow_json_output allow_json
+		@data[:allow_json] = allow_json
+	end
+
+	def self.option name, description, type: :boolean, default: false
+		@data[:options][name.to_sym] = {
+				description: description,
+				type: type,
+				default: default
+		}
+	end
+
+	def self.default_action &block
+		@data[:default_action] = block
+	end
+
+	def self.pre_hook &block
+		@data[:pre_hook] = block
+	end
+
+	def self.post_hook &block
+		@data[:post_hook] = block
+	end
+
+	##
+	# Data Retrieval
+	##
+	def self.configuration
+		@data
+	end
+
+end