shaddox 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3f9be2b6fb62fa15d6c5cb98c110fea75c8b70b
+  data.tar.gz: ea313d4220ef409ac86f8b8d04f99b045df00db5
+SHA512:
+  metadata.gz: a9f429ea4bb50f06b0a5696d89b684d83c9d1760d0f968c11384a9b028234ab18acfe62715d980f81060ce4c36782a5984d29b3eaa9defdf136432e030dc3235
+  data.tar.gz: df693c30910cbd855e63b39b4325f0bb6df6135d60314aa9898bd5541f6a8e0746d715500e12b6b6dbdeb7a423c7d2fa8745b3bd6bf26f3040c7ee5146d1def0

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.vagrant/

data/Doxfile

@@ -0,0 +1,37 @@
+server :vagrant, {
+	:host => "localhost",
+	:user => 'vagrant',
+	:ssh => {
+		:port => 2222,
+		:password => 'vagrant'
+	},
+	:installer => :apt
+}
+
+repo :test, {
+	:foo => "bar"
+}
+
+task :foo do
+	sh "echo 'foo'"
+end
+
+task :foobar => :foo do
+	sh "echo 'bar'"
+end
+
+task :install => :foobar do
+	install 'zsh'
+	sh "echo 'test'"
+	sh "echo 'test2'"
+	sh "echo 'test3'"
+	repo_clone :test, "dest"
+end
+
+task :broken => :foo do
+	sh "notacommand"
+end
+
+task :sudo do
+	sh "sudo echo 'this is a sudo echo'"
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shaddox.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 joshglendenning
+
+MIT License
+
+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,81 @@
+# Shaddox
+
+This project is entirely unfinished. Please don't actually use it.
+
+Ruby gem for provisioning systems. Here's the idea of how it works:
+
+Provisioning/deployment configuration is defined in a Doxfile in the project directory. It might look something like this:
+```ruby
+server :box1, {
+    :address => "0.0.0.0"
+    :installer => :apt
+}
+
+repo :main, {
+    :repository => "https://github.com/foo/bar.git"
+}
+
+task :provision do
+    install 'tree'
+    sh "tree"
+    sh "echo 'Hello, world!'"
+end
+
+task :deploy do
+    target_dir = "~/target-dir"
+    auto_deploy_git :main, target_dir
+    cd target_dir do
+        ls
+    end
+    symlink "#{target_dir}/current", "~/foobar"
+end
+```
+
+You could then use shaddox to provision the server `:box1`
+```shaddox provision box1```
+or your local machine
+```shaddox provision local```
+
+To execute provisioning blocks on the target machine, shaddow will generate a shadow script that might look something like this:
+```ruby
+require 'shaddox/shadow'
+Shadow.new(:installer => :apt) do
+    ## Begin compiled task ##
+    
+    install 'tree'
+    sh "tree"
+    sh "echo 'Hello, world!"
+    
+    ## End compiled task ##
+end
+```
+
+Shaddox then asks the target machine to execute the shaddow, ensuring that Ruby and the Shaddox gem are install first (using bootstrap.sh). Typically on remote machines this means SCP'ing a generated shadow over and executing it over SSH.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shaddox'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shaddox
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/shaddox/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Vagrantfile

@@ -0,0 +1,122 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "chef/debian-7.4"
+
+  # Disable automatic box update checking. If you disable this, then
+  # boxes will only be checked for updates when the user runs
+  # `vagrant box outdated`. This is not recommended.
+  # config.vm.box_check_update = false
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network "forwarded_port", guest: 80, host: 8080
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network "private_network", ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network "public_network"
+
+  # If true, then any SSH connections made will enable agent forwarding.
+  # Default value: false
+  # config.ssh.forward_agent = true
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  # config.vm.synced_folder "../data", "/vagrant_data"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider "virtualbox" do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
+
+  # Enable provisioning with CFEngine. CFEngine Community packages are
+  # automatically installed. For example, configure the host as a
+  # policy server and optionally a policy file to run:
+  #
+  # config.vm.provision "cfengine" do |cf|
+  #   cf.am_policy_hub = true
+  #   # cf.run_file = "motd.cf"
+  # end
+  #
+  # You can also configure and bootstrap a client to an existing
+  # policy server:
+  #
+  # config.vm.provision "cfengine" do |cf|
+  #   cf.policy_server_address = "10.0.2.15"
+  # end
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file default.pp in the manifests_path directory.
+  #
+  # config.vm.provision "puppet" do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "site.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision "chef_solo" do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { mysql_password: "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision "chef_client" do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/bin/shaddox

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'shaddox'
+task = ARGV[0]
+target = ARGV[1] || 'localhost'
+config = Shaddox::Config.new
+config.invoke(task.to_sym, target.to_sym)

data/install.sh

@@ -0,0 +1,12 @@
+#! /bin/sh
+#
+# install.sh
+# Copyright (C) 2014 joshglendenning <joshglendenning@Q.local>
+#
+# Distributed under terms of the MIT license.
+#
+
+
+gem build shaddox.gemspec
+gem install shaddox-*
+rm shaddox-*

data/lib/shaddox/config.rb

@@ -0,0 +1,97 @@
+module Shaddox
+	class Config
+		attr_accessor :servers, :targets, :repos, :tasks
+		def initialize(doxfilename = "./Doxfile")
+			if !File.exists?(doxfilename)
+				puts "Doxfile could not be found.".red
+				exit(1)
+			end
+
+			@servers = Hash.new
+			@targets = Hash.new {|hsh, key| @servers[key]}  # Fall back on @servers hash for missing targets
+			@tasks = Hash.new
+			@repos = Hash.new
+
+			@targets[:localhost] = Localhost.new
+
+			instance_eval(File.read(doxfilename), doxfilename)
+		end
+
+		def explode_target(target_key)
+			exploded = []
+			[@targets[target_key]].flatten.each do |target|
+				if target.is_a? Symbol
+					exploded += explode_target(target)
+				else
+					exploded.push(target)
+				end
+			end
+			exploded
+		end
+
+		def invoke(task_key, target_key, opts = {})
+			explode_target(target_key).each do |target|
+				info "Deploying to #{target_key}..."
+				begin
+					script_opts = {}
+					script_opts[:installer] = target.installer if target.respond_to? :installer
+					script = ShadowScript.new(self, task_key, script_opts)
+					target.deploy(script, opts)
+					info "Provisioning on :#{target_key} complete.".green
+				rescue TargetError => e
+					err "Provisioning on :#{target_key} failed:".red
+					puts e.message.red
+				rescue => e
+					err "Provisioning on :#{target_key} failed:".red
+					puts e.message.red
+				end
+			end
+		end
+
+		## DSL Methods ##
+
+		# ### Add a server
+		# info: A hash containing the server's info. Allowed keys:
+		#	:address (required)
+		#	:user
+		#	:port
+		#	:identity_file
+		#	:ssh_options
+		def server(key, info)
+			@servers[key] = Server.new(info)
+		end
+
+		# ### Add a target
+		# linked_target: A symbol or Array of symbols representing
+		#	the other targets/servers that this target invokes
+		def target(key, linked_target)
+			@targets[key] = linked_target
+		end
+
+		# ### Add a repo
+		# info: A hash containing the repo's info. Allowed keys:
+		#	:repository (required)
+		#	:branch
+		def repo(key, info)
+			@repos[key] = Repo.new(info)
+		end
+
+		# ### Add a package
+		# blk: A block of code to be executed in the context of the target[s]
+		#	specified when running Shaddox
+		#	key can be bound to a list to define dependencies, like with Rake
+		#	task :example => :some_dep do ...
+		#	task :example => [:dep1, :dep2] do ...
+		def task(arg, &block)
+			if arg.is_a? Hash
+				fail "Task Argument Error" if arg.size != 1
+				key, deps = arg.map { |k, v| [k, v] }.first
+				@tasks[key] = Task.new(block, deps)
+			else
+				fail "Task Argument Error" if !arg.is_a? Symbol
+				@tasks[arg] = Task.new(block, [])
+			end
+		end
+
+	end
+end

data/lib/shaddox/repo.rb

@@ -0,0 +1,12 @@
+module Shaddox
+	class Repo
+		attr_reader :info
+		def initialize(info)
+			@info = info
+		end
+
+		def to_source
+			"Shaddox::Repo.new(#{@info.inspect})"
+		end
+	end
+end

data/lib/shaddox/settings.rb

@@ -0,0 +1,42 @@
+module Shaddox
+	class Settings < Hash
+		def method_missing(meth, *args, &blk)
+			name = meth.to_s
+
+			return evaluate(self[meth])  if name.size == 1
+
+			# Ruby 1.8.7 doesn't let you do string[-1]
+			key, suffix = name[0..-2].to_sym, name[-1..-1]
+
+			case suffix
+			when '='
+				self[key] = args.first
+			when '?'
+				include? key
+			when '!'
+				raise Error, "Setting :#{key} is not set" unless include?(key)
+				evaluate self[key]
+			else
+				evaluate self[meth]
+			end
+		end
+
+		def evaluate(value)
+			if value.is_a?(Proc)
+				value.call
+			else
+				value
+			end
+		end
+	end
+	module SettingContainer
+		def init_settings(default_settings = {})
+			@settings = Settings.new.update(default_settings)
+		end
+
+		# Hook to loop up values in @info
+		def method_missing(meth, *args, &blk)
+			@settings.send meth, *args
+		end
+	end
+end

data/lib/shaddox/shadow.rb

@@ -0,0 +1,84 @@
+class String
+	def exp_path
+		File.expand_path(self)
+	end
+end
+
+module Shaddox
+
+	class Shadow
+		require 'fileutils'
+		#include FileUtils
+		def initialize(options, &block)
+			@verbose = options[:verbose] || true
+			@installer = options[:installer]
+			@tmppath = options[:tmppath] || '/tmp/shaddox/'
+			@required = true
+			instance_eval(&block)
+		end
+
+		def optional(&block)
+			@required = false
+			instance_eval(&block)
+			@required = true
+		end
+
+		def sh(command, args = nil)
+			line = "#{command}"
+			line += " #{args.join(" ")}" if args
+			info "Running '#{line}' in '#{Dir.pwd}'", 1 if @verbose
+			system(command, *args)
+			raise "#{line} failed" unless $? == 0 or !@required
+		end
+
+		def cd(path, &block)
+			current_path = Dir.pwd
+			FileUtils.cd(path.exp_path)
+			instance_eval(&block)
+			FileUtils.cd(current_path)
+		end
+
+		def exists(path)
+			system("test -e #{path.exp_path}")
+		end
+
+		def ln_s(source, dest, opts = {})
+			info "Linking '#{source}' to '#{dest}'", 1 if @verbose
+			FileUtils::ln_s(source.exp_path, dest.exp_path, opts)
+		end
+
+		def mkdir(path)
+			info "Ensuring directory '#{path}' exists", 1 if @verbose
+			FileUtils::mkdir_p(path.exp_path)
+		end
+
+		def repo_clone(repo_key, path)
+			puts "Cloning repo at #{repos[repo_key].info[:foo]} to #{path.exp_path}"
+		end
+
+		def install(package)
+			unless @installer
+				warn "No package manager is defined for this target.", 1
+				puts "-------------------"
+				require 'highline/import'
+				choose do |menu|
+					menu.prompt = "Please select a package manager to use:"
+
+					menu.choice(:apt) { @installer = :apt }
+					menu.choice(:brew) { @installer = :brew }
+				end
+				puts "-------------------"
+			end
+			raise "No installer specified for this target!" unless @installer
+			info "Ensuring #{package} is installed with #{@installer}", 1 if @verbose
+			unless system("type #{package} >/dev/null 2>&1")
+				case @installer
+				when :apt
+					sh "sudo apt-get install -y #{package}"
+				when :brew
+					sh "brew install #{package}"
+				end
+			end
+		end
+	end
+end

data/lib/shaddox/shadow_script.rb

@@ -0,0 +1,58 @@
+module Shaddox
+	class ShadowScript
+		attr_reader :script
+		def initialize(config, task_key, opts = {})
+			# Initialize properties
+			@installer = opts[:installer]
+			@config = config
+			@cast_tasks = []
+
+			# Generate script
+			params = "{}"
+			params = "{:installer => :#{@installer}}" if @installer
+			@script = %Q{
+require 'shaddox'
+Shaddox::Shadow.new(#{params}) do
+	## begin generated shadow ##
+			}
+			add_repos
+			cast(task_key)
+			@script += %Q{
+	## end generated shadow ##
+end
+			}
+		end
+
+		## cast
+		# Retrieves a task from the @config and ensures all of its dependencies
+		# have been added to the script before adding itself. Tasks are only cast
+		# once to elimate redundency.
+		def cast(task_key)
+			task = @config.tasks[task_key]
+			if !task
+				raise "The task :#{task_key} could not be found. Please check your Doxfile and try again."
+			end
+			task.deps.each do |dep_key|
+				cast(dep_key) if !@cast_tasks.include? dep_key
+			end
+			@script += %Q{
+	## #{task_key} ##
+	#{task.to_source}
+			}
+			@cast_tasks.push(task_key)
+		end
+
+		## add_repos
+		# Retrieves all repos from the @config and ensures their data is copied
+		# to the script for use by tasks.
+		def add_repos
+			@script += %Q(
+	repos = {)
+			@config.repos.each do |key, repo|
+				@script += ":#{key} => #{repo.to_source}"
+			end
+			@script += %Q(
+	})
+		end
+	end
+end

data/lib/shaddox/target.rb

@@ -0,0 +1,139 @@
+module Shaddox
+	class TargetError < StandardError ; end
+	class Target
+		def new_actor
+			raise "new_actor method must be implemented by Target subclass"
+		end
+		def deploy(shadow_script, opts)
+			tmpdir = opts[:tmpdir] || '/tmp/shaddox'
+			shadow_script_path = "#{tmpdir}/shadow_script.rb"
+			# Everything inside this block is handled by the target's actor (typically an SSH session)
+			new_actor do
+
+				rm_tmpdir = lambda { 
+					unless !exec("test -e #{tmpdir}")
+						info "Removing #{tmpdir}", 1
+						exec("rm -r #{tmpdir}")
+					end
+				}
+
+				rm_tmpdir.call() if opts[:force]
+
+				# Try to create tmpdir:
+				info "Creating #{tmpdir}", 1
+				unlocked = exec "mkdir #{tmpdir}"
+
+				# Abort if the tmpdir already exists
+				raise TargetError, "Shaddox is already running on this machine. Try again later." unless unlocked
+
+				begin
+					# Initial provisioning to ensure that we have everyting we need to execute a shadow script:
+					ruby_installed = exec 'type ruby >/dev/null'
+					raise TargetError, "Ruby is required to use shaddox. Please install it manually." unless ruby_installed
+					gem_installed = exec 'type gem >/dev/null'
+					raise TargetError, "Gem is required to use shaddox. Please install it manually." unless gem_installed
+					shaddox_installed = lambda { exec 'gem list shaddox -i' }
+					info "Installing/updating shaddox...", 1
+					exec "sudo gem install shaddox"
+					unless shaddox_installed.call()
+						raise TargetError, "Shaddox could not be automatically installed. Please install manually with 'gem install shaddox'."
+					end
+
+					# Push the shadow script to tmpdir:
+					info "Writing shadow script", 1
+					write_file(shadow_script.script, shadow_script_path)
+
+					# Execute the shadow script:
+					info "Executing shadow script", 1
+					raise TargetError, "Shadow script was not executed successfully." unless exec "ruby #{shadow_script_path}"
+
+					rm_tmpdir.call() unless opts[:keep_tmp_dir]
+				rescue => e
+					# Make sure the tmpdir is removed even if the provisioning fails:
+					rm_tmpdir.call() unless opts[:keep_tmp_dir]
+					raise e
+				end
+			end
+		end
+	end
+
+	class Actor
+		def initialize(&block)
+			instance_eval(&block)
+		end
+		def exec(command)
+			raise "exec method must be implemented by Actor subclass"
+		end
+		def write_file(content, dest_path)
+			raise "write_file method must be implemented by Actor subclass"
+		end
+	end
+
+	class Localhost < Target
+		def new_actor(&block)
+			LocalActor.new(&block)
+		end
+		class LocalActor < Actor
+			def exec(command)
+				system(command)
+			end
+			def write_file(content, dest_path)
+				File.open(dest_path, 'w') { |f| f.write(content) }
+			end
+		end
+	end
+
+	class Server < Target
+		include SettingContainer
+		require 'net/ssh'
+		# ###
+		# Constructor for Server
+		# @info param A hash containing the server's info. Allowed keys:
+		#	:host (required)
+		#	:user (required)
+		#	:ssh  (required for authentication)
+		#	:installer
+		#
+		attr_reader :host, :user, :ssh, :installer
+		def initialize(info)
+			@host = info[:host]
+			@user = info[:user]
+			@ssh = info[:ssh]
+			@installer = info[:installer]
+		end
+		def new_actor(&block)
+			SSHActor.new(host, user, ssh, &block)
+		end
+		class SSHActor < Actor
+			def initialize(host, user, ssh_opts, &block)
+				Net::SSH.start(host, user, ssh_opts) do |ssh|
+					@ssh = ssh
+					super(&block)
+				end
+			end
+			def exec(command)
+				exit_code = nil
+				@ssh.open_channel do |channel|
+					channel.exec(command) do |ch, success|
+						#return nil if !success
+						ch.on_data do |ch, data|
+							$stdout.print data
+							if data =~ /^\[sudo\] password for user:/
+								channel.send_data(gets.strip)
+							end
+						end
+						ch.on_request('exit-status') do |ch, data|
+							exit_code = data.read_long
+						end
+					end
+				end
+				@ssh.loop
+				exit_code == 0 ? true : false
+			end
+			def write_file(content, dest_path)
+				require 'shellwords'
+				exec "echo #{Shellwords.shellescape(content)} > #{dest_path}"
+			end
+		end
+	end
+end

data/lib/shaddox/task.rb

@@ -0,0 +1,18 @@
+module Shaddox
+	class Task
+		attr_accessor :block, :deps
+		def initialize(block, deps)
+			@block = block
+			@deps = [deps].flatten
+		end
+
+		def to_source
+			require 'sourcify'
+			if @block
+				@block.to_source(:strip_enclosure => true)
+			else
+				"# Empty block #"
+			end
+		end
+	end
+end

data/lib/shaddox/ui.rb

@@ -0,0 +1,55 @@
+def prefix(level)
+	"=" * level + "> "
+end
+def warn(msg, level = 0)
+	puts prefix(level) + msg.yellow
+end
+
+def err(msg, level = 0)
+	puts prefix(level) + msg.red
+end
+
+def info(msg, level = 0)
+	out =  prefix(level)
+	if level == 0
+		out += msg.blue
+	else
+		out += msg
+	end
+	puts out
+end
+
+class String
+	# colorization
+	def colorize(color_code)
+		"\e[#{color_code}m#{self}\e[0m"
+	end
+
+	def red
+		colorize(31)
+	end
+
+	def green
+		colorize(32)
+	end
+
+	def yellow
+		colorize(33)
+	end
+
+	def blue
+		colorize(34)
+	end
+
+	def pink
+		colorize(35)
+	end
+
+	def cyan
+		colorize(36)
+	end
+
+	def gray
+		colorize(90)
+	end
+end

data/lib/shaddox/version.rb

@@ -0,0 +1,3 @@
+module Shaddox
+  VERSION = "0.0.2"
+end

data/lib/shaddox.rb

@@ -0,0 +1,9 @@
+require "shaddox/version"
+require "shaddox/ui"
+require "shaddox/settings"
+require "shaddox/target"
+require "shaddox/task"
+require "shaddox/repo"
+require "shaddox/shadow"
+require "shaddox/shadow_script"
+require "shaddox/config"

data/scripts/bootstrap.sh

@@ -0,0 +1,18 @@
+#! /bin/bash
+#
+# bootstrap.sh
+# Copyright (C) 2014 josh <josh@ubuntu>
+#
+# Distributed under terms of the MIT license.
+#
+
+ensure_installed() {
+	type $1 >/dev/null 2>&1 || { echo >&2 "$1 is required to use shaddox. Please install it manually."; exit 1;  }
+}
+
+ensure_installed(ruby)
+ensure_installed(gem)
+
+if ! gem list shaddox -i; then
+	gem install shaddox
+fi

data/shaddox.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shaddox/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shaddox"
+  spec.version       = Shaddox::VERSION
+  spec.authors       = ["joshglendenning"]
+  spec.email         = ["joshglendenning@gmail.com"]
+  spec.summary       = %q{Ruby system provisioner.}
+  spec.description   = %q{Ruby-based system provisioning tool.}
+  spec.homepage      = "http://nominaltech.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "sourcify", "~> 0.6.0.rc4"
+  spec.add_dependency "net-ssh", "~> 2.9"
+  spec.add_dependency "highline", "~> 1.6"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: shaddox
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- joshglendenning
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0.rc4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0.rc4
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Ruby-based system provisioning tool.
+email:
+- joshglendenning@gmail.com
+executables:
+- shaddox
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Doxfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Vagrantfile
+- bin/shaddox
+- install.sh
+- lib/shaddox.rb
+- lib/shaddox/config.rb
+- lib/shaddox/repo.rb
+- lib/shaddox/settings.rb
+- lib/shaddox/shadow.rb
+- lib/shaddox/shadow_script.rb
+- lib/shaddox/target.rb
+- lib/shaddox/task.rb
+- lib/shaddox/ui.rb
+- lib/shaddox/version.rb
+- scripts/bootstrap.sh
+- shaddox.gemspec
+homepage: http://nominaltech.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby system provisioner.
+test_files: []