vli 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tyler Flint
+
+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,29 @@
+# Vli
+
+Vagrant Like Interface is a library of components extracted from the vagrant project to aid in building command line interfaces. If you've ever used or extended the vagrant project you can appreciate the brilliance in the architecture. Special thanks to the vagrant project: https://github.com/mitchellh/vagrant
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vli'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vli
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/vli.rb

@@ -0,0 +1,10 @@
+require "vli/version"
+
+module Vli
+  autoload :Action,   'vli/action'
+  autoload :Command,  'vli/command'
+  autoload :Error,    'vli/error'
+  autoload :Registry, 'vli/registry'
+  autoload :UI,       'vli/ui'
+  autoload :Util,     'vli/util'
+end

data/lib/vli/action.rb

@@ -0,0 +1,9 @@
+module Vli
+  module Action
+    autoload :Builder,      'vli/action/builder'
+    autoload :Env,          'vli/action/env'
+    autoload :Environment,  'vli/action/environment'
+    autoload :Runner,       'vli/action/runner'
+    autoload :Warden,       'vli/action/warden'
+  end
+end

data/lib/vli/action/builder.rb

@@ -0,0 +1,128 @@
+module Vli
+  module Action
+    # Action builder which provides a nice DSL for building up
+    # a middleware sequence for Vli actions. This code is based
+    # heavily off of `Rack::Builder` and `ActionDispatch::MiddlewareStack`
+    # in Rack and Rails, respectively.
+    #
+    # Usage
+    #
+    # Building an action sequence is very easy:
+    #
+    #     app = Vli::Action::Builder.new do
+    #       use MiddlewareA
+    #       use MiddlewareB
+    #     end
+    #
+    #     Vli::Action.run(app)
+    #
+    class Builder
+      # Initializes the builder. An optional block can be passed which
+      # will be evaluated in the context of the instance.
+      def initialize(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      # Returns a mergeable version of the builder. If `use` is called with
+      # the return value of this method, then the stack will merge, instead
+      # of being treated as a separate single middleware.
+      def flatten
+        lambda do |env|
+          self.call(env)
+        end
+      end
+
+      # Adds a middleware class to the middleware stack. Any additional
+      # args and a block, if given, are saved and passed to the initializer
+      # of the middleware.
+      #
+      # @param [Class] middleware The middleware class
+      def use(middleware, *args, &block)
+        # Prepend with a environment setter if args are given
+        if !args.empty? && args.first.is_a?(Hash) && middleware != Env::Set
+          self.use(Env::Set, args.shift, &block)
+        end
+
+        if middleware.kind_of?(Builder)
+          # Merge in the other builder's stack into our own
+          self.stack.concat(middleware.stack)
+        else
+          self.stack << [middleware, args, block]
+        end
+
+        self
+      end
+
+      # Inserts a middleware at the given index or directly before the
+      # given middleware object.
+      def insert(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.insert(index, [middleware, args, block])
+      end
+
+      alias_method :insert_before, :insert
+
+      # Inserts a middleware after the given index or middleware object.
+      def insert_after(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        raise "no such middleware to insert after: #{index.inspect}" unless index
+        insert(index + 1, middleware, *args, &block)
+      end
+
+      # Replaces the given middlware object or index with the new
+      # middleware.
+      def replace(index, middleware, *args, &block)
+        if index.is_a?(Integer)
+          delete(index)
+          insert(index, middleware, *args, &block)
+        else
+          insert_before(index, middleware, *args, &block)
+          delete(index)
+        end
+      end
+
+      # Deletes the given middleware object or index
+      def delete(index)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.delete_at(index)
+      end
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+
+      protected
+
+      # Returns the numeric index for the given middleware object.
+      #
+      # @param [Object] object The item to find the index for
+      # @return [Integer]
+      def index(object)
+        stack.each_with_index do |item, i|
+          return i if item[0] == object
+        end
+
+        nil
+      end
+
+      # Returns the current stack of middlewares. You probably won't
+      # need to use this directly, and it's recommended that you don't.
+      #
+      # @return [Array]
+      def stack
+        @stack ||= []
+      end
+
+      # Converts the builder stack to a runnable action sequence.
+      #
+      # @param [Vli::Action::Environment] env The action environment
+      # @return [Object] A callable object
+      def to_app(env)
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(stack.dup, env)
+      end
+    end
+  end
+end

data/lib/vli/action/env.rb

@@ -0,0 +1,5 @@
+module Vli
+  module Env
+    autoload :Set, 'vli/action/env/set'
+  end
+end

data/lib/vli/action/env/set.rb

@@ -0,0 +1,21 @@
+module Vli
+  module Action
+    module Env
+      # A middleware which just sets up the environment with some
+      # options which are passed to it.
+      class Set
+        def initialize(app, env, options=nil)
+          @app     = app
+          @options = options || {}
+        end
+
+        def call(env)
+          # Merge the options that were given to us
+          env.merge!(@options)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vli/action/environment.rb

@@ -0,0 +1,10 @@
+module Vli
+  module Action
+    # Represents an action environment which is what is passed
+    # to the `call` method of each action. This environment contains
+    # some helper methods for accessing the environment as well
+    # as being a hash, to store any additional options.
+    class Environment < Util::HashWithIndifferentAccess
+    end
+  end
+end

data/lib/vli/action/runner.rb

@@ -0,0 +1,56 @@
+# TODO:
+# * env.lock
+
+module Vli
+  module Action
+    class Runner
+      @@reported_interrupt = false
+
+      def initialize(registry, globals=nil, &block)
+        @registry     = registry
+        @globals      = globals || {}
+        @lazy_globals = block
+      end
+
+      def run(callable_id, options=nil)
+        callable = callable_id
+        callable = Builder.new.use(callable_id) if callable_id.kind_of?(Class)
+        callable = @registry.get(callable_id) if callable_id.kind_of?(Symbol)
+        raise ArgumentError, "Argument to run must be a callable object or registered action." if !callable || !callable.respond_to?(:call)
+
+        # Create the initial environment with the options given
+        environment = Environment.new
+        environment.merge!(@globals)
+        environment.merge!(@lazy_globals.call) if @lazy_globals
+        environment.merge!(options || {})
+
+        # Run the action chain in a busy block, marking the environment as
+        # interrupted if a SIGINT occurs, and exiting cleanly once the
+        # chain has been run.
+        ui = environment[:ui] if environment.has_key?(:ui)
+        int_callback = lambda do
+          if environment[:interrupted]
+            ui.error exit_immediately_message if ui
+            abort
+          end
+
+          ui.warn waiting_cleanup_message if ui && !@@reported_interrupt
+          environment[:interrupted] = true
+          @@reported_interrupt = true
+        end
+
+        # We place a process lock around every action that is called
+        Util::Busy.busy(int_callback) { callable.call(environment) }
+      end
+
+      def exit_immediately_message
+        "Exiting immediately, without cleanup!"
+      end
+
+      def waiting_cleanup_message
+        "Waiting for cleanup before exiting..."
+      end
+
+    end
+  end
+end

data/lib/vli/action/warden.rb

@@ -0,0 +1,86 @@
+module Vli
+  module Action
+    # The action warden is a middleware which injects itself between
+    # every other middleware, watching for exceptions which are raised
+    # and performing proper cleanup on every action by calling the `recover`
+    # method. The warden therefore allows middlewares to not worry about
+    # exceptional events, and by providing a simple callback, can clean up
+    # in any erroneous case.
+    #
+    # Warden will "just work" behind the scenes, and is not of particular
+    # interest except to those who are curious about the internal workings
+    # of Vli.
+    class Warden
+      attr_accessor :actions, :stack
+
+      def initialize(actions, env)
+        @stack = []
+        @actions = actions.map { |m| finalize_action(m, env) }
+      end
+
+      def call(env)
+        return if @actions.empty?
+
+        begin
+          # Call the next middleware in the sequence, appending to the stack
+          # of "recoverable" middlewares in case something goes wrong!
+          raise Error::VliInterrupt if env[:interrupted]
+          action = @actions.shift
+          @stack.unshift(action).first.call(env)
+          raise Error::VliInterrupt if env[:interrupted]
+        rescue SystemExit
+          # This means that an "exit" or "abort" was called. In these cases,
+          # we just exit immediately.
+          raise
+        rescue Exception => e
+          env["Vli.error"] = e
+
+          # Something went horribly wrong. Start the rescue chain then
+          # reraise the exception to properly kick us out of limbo here.
+          begin_rescue(env)
+          raise
+        end
+      end
+
+      # Begins the recovery sequence for all middlewares which have run.
+      # It does this by calling `recover` (if it exists) on each middleware
+      # which has already run, in reverse order.
+      def begin_rescue(env)
+        @stack.each do |act|
+          if act.respond_to?(:recover)
+            act.recover(env)
+          end
+        end
+
+        # Clear stack so that warden down the middleware chain doesn't
+        # rescue again.
+        @stack.clear
+      end
+
+      # A somewhat confusing function which simply initializes each
+      # middleware properly to call the next middleware in the sequence.
+      def finalize_action(action, env)
+        klass, args, block = action
+
+        # Default the arguments to an empty array. Otherwise in Ruby 1.8
+        # a `nil` args will actually pass `nil` into the class.
+        args ||= []
+
+        if klass.is_a?(Class)
+          # A action klass which is to be instantiated with the
+          # app, env, and any arguments given
+          klass.new(self, env, *args, &block)
+        elsif klass.respond_to?(:call)
+          # Make it a lambda which calls the item then forwards
+          # up the chain
+          lambda do |e|
+            klass.call(e)
+            self.call(e)
+          end
+        else
+          raise "Invalid action: #{action.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/vli/command.rb

@@ -0,0 +1,5 @@
+module Vli
+  module Command
+    autoload :Base, 'vli/command/base'
+  end
+end

data/lib/vli/command/base.rb

@@ -0,0 +1,64 @@
+# Credit:
+# special thanks to Vagrant project: https://github.com/mitchellh/vagrant
+# where the source of this module was originally extracted.
+
+module Vli
+  module Command
+    class Base
+      
+      def initialize(argv, env)
+        @argv   = argv
+        @env    = env
+      end
+
+      def execute; end
+
+      # This method will split the argv given into three parts: the
+      # flags to this command, the subcommand, and the flags to the
+      # subcommand. For example:
+      #
+      #     -v status -h -v
+      #
+      # The above would yield 3 parts:
+      #
+      #     ["-v"]
+      #     "status"
+      #     ["-h", "-v"]
+      #
+      # These parts are useful because the first is a list of arguments
+      # given to the current command, the second is a subcommand, and the
+      # third are the commands given to the subcommand.
+      #
+      # @return [Array] The three parts.
+      def split_main_and_subcommand(argv)
+        # Initialize return variables
+        main_args   = nil
+        sub_command = nil
+        sub_args    = []
+
+        # We split the arguments into two: One set containing any
+        # flags before a word, and then the rest. The rest are what
+        # get actually sent on to the subcommand.
+        argv.each_index do |i|
+          if !argv[i].start_with?("-")
+            # We found the beginning of the sub command. Split the
+            # args up.
+            main_args   = argv[0, i]
+            sub_command = argv[i]
+            sub_args    = argv[i + 1, argv.length - i + 1]
+
+            # Break so we don't find the next non flag and shift our
+            # main args.
+            break
+          end
+        end
+
+        # Handle the case that argv was empty or didn't contain any subcommand
+        main_args = argv.dup if main_args.nil?
+
+        return [main_args, sub_command, sub_args]
+      end
+
+    end
+  end
+end

data/lib/vli/error.rb

@@ -0,0 +1,7 @@
+module Vli
+  module Error
+
+    class VliInterrupt < StandardError; end
+
+  end
+end

data/lib/vli/registry.rb

@@ -0,0 +1,56 @@
+# Credit:
+# special thanks to Vagrant project: https://github.com/mitchellh/vagrant
+# where the source of this module was originally extracted.
+
+module Vli
+  # Register components in a single location that can be queried.
+  #
+  # This allows certain components (such as guest systems, configuration
+  # pieces, etc.) to be registered and queried.
+  class Registry
+    def initialize
+      @actions = {}
+      @results_cache = {}
+    end
+
+    # Register a callable by key.
+    #
+    # The callable should be given in a block which will be lazily evaluated
+    # when the action is needed.
+    #
+    # If an action by the given name already exists then it will be
+    # overwritten.
+    def register(key, value=nil, &block)
+      block = lambda { value } if value
+      @actions[key] = block
+    end
+
+    # Get an action by the given key.
+    #
+    # This will evaluate the block given to `register` and return the resulting
+    # action stack.
+    def get(key)
+      return nil if !@actions.has_key?(key)
+      return @results_cache[key] if @results_cache.has_key?(key)
+      @results_cache[key] = @actions[key].call
+    end
+    alias :[] :get
+
+    # Iterate over the keyspace.
+    def each(&block)
+      @actions.each do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Converts this registry to a hash
+    def to_hash
+      result = {}
+      self.each do |key, value|
+        result[key] = value
+      end
+
+      result
+    end
+  end
+end

data/lib/vli/ui.rb

@@ -0,0 +1,161 @@
+module Vli
+  module UI
+    # Vli UIs handle communication with the outside world (typically
+    # through a shell). They must respond to the following methods:
+    #
+    # * `info`
+    # * `warn`
+    # * `error`
+    # * `success`
+    class Interface
+      attr_accessor :resource
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      [:ask, :warn, :error, :info, :success].each do |method|
+        define_method(method) do |message, *opts|
+          define_method(method) { |*args| }
+        end
+      end
+
+      [:clear_line, :report_progress].each do |method|
+        define_method(method) { |*args| }
+      end
+    end
+
+    # This is a UI implementation that does nothing.
+    class Silent < Interface
+      def ask(*args)
+        super
+
+        # Silent can't do this, obviously.
+        raise Errors::UIExpectsTTY
+      end
+    end
+
+    # This is a UI implementation that outputs the text as is. It
+    # doesn't add any color.
+    class Basic < Interface
+      include Util::SafePuts
+
+      # Use some light meta-programming to create the various methods to
+      # output text to the UI. These all delegate the real functionality
+      # to `say`.
+      [:info, :warn, :error, :success].each do |method|
+        class_eval <<-CODE
+          def #{method}(message, *args)
+            super(message)
+            say(#{method.inspect}, message, *args)
+          end
+        CODE
+      end
+
+      def ask(message, opts=nil)
+        super(message)
+
+        # We can't ask questions when the output isn't a TTY.
+        raise Errors::UIExpectsTTY if !$stdin.tty?
+
+        # Setup the options so that the new line is suppressed
+        opts ||= {}
+        opts[:new_line] = false if !opts.has_key?(:new_line)
+        opts[:prefix]   = false if !opts.has_key?(:prefix)
+
+        # Output the data
+        say(:info, message, opts)
+
+        # Get the results and chomp off the newline
+        $stdin.gets.chomp
+      end
+
+      # This is used to output progress reports to the UI.
+      # Send this method progress/total and it will output it
+      # to the UI. Send `clear_line` to clear the line to show
+      # a continuous progress meter.
+      def report_progress(progress, total, show_parts=true)
+        if total && total > 0
+          percent = (progress.to_f / total.to_f) * 100
+          line    = "Progress: #{percent.to_i}%"
+          line   << " (#{progress} / #{total})" if show_parts
+        else
+          line    = "Progress: #{progress}"
+        end
+
+        info(line, :new_line => false)
+      end
+
+      def clear_line
+        reset = "\r"
+        reset += "\e[0K" unless Util::Platform.windows?
+        reset
+
+        info(reset, :new_line => false)
+      end
+
+      # This method handles actually outputting a message of a given type
+      # to the console.
+      def say(type, message, opts=nil)
+        defaults = { :new_line => true, :prefix => true }
+        opts     = defaults.merge(opts || {})
+
+        # Determine whether we're expecting to output our
+        # own new line or not.
+        printer = opts[:new_line] ? :puts : :print
+
+        # Determine the proper IO channel to send this message
+        # to based on the type of the message
+        channel = type == :error || opts[:channel] == :error ? $stderr : $stdout
+
+        # Output!
+        safe_puts(format_message(type, message, opts),
+                  :io => channel, :printer => printer)
+      end
+
+      # This is called by `say` to format the message for output.
+      def format_message(type, message, opts=nil)
+        opts ||= {}
+        message = "[#{@resource}] #{message}" if opts[:prefix]
+        message
+      end
+    end
+
+    # This is a UI implementation that outputs color for various types
+    # of messages. This should only be used with a TTY that supports color,
+    # but is up to the user of the class to verify this is the case.
+    class Colored < Basic
+      # Terminal colors
+      COLORS = {
+        :clear  => "\e[0m",
+        :red    => "\e[31m",
+        :green  => "\e[32m",
+        :yellow => "\e[33m"
+      }
+
+      # Mapping between type of message and the color to output
+      COLOR_MAP = {
+        :warn    => COLORS[:yellow],
+        :error   => COLORS[:red],
+        :success => COLORS[:green]
+      }
+
+      # This is called by `say` to format the message for output.
+      def format_message(type, message, opts=nil)
+        # Get the format of the message before adding color.
+        message = super
+
+        # Colorize the message if there is a color for this type of message,
+        # either specified by the options or via the default color map.
+        if opts.has_key?(:color)
+          color   = COLORS[opts[:color]]
+          message = "#{color}#{message}#{COLORS[:clear]}"
+        else
+          message = "#{COLOR_MAP[type]}#{message}#{COLORS[:clear]}" if COLOR_MAP[type]
+        end
+
+        message
+      end
+    end
+  end
+end

data/lib/vli/util.rb

@@ -0,0 +1,8 @@
+module Vli
+  module Util
+    autoload :Busy,                       'vli/util/busy'
+    autoload :HashWithIndifferentAccess,  'vli/util/hash_with_indifferent_access'
+    autoload :Platform,                   'vli/util/platform'
+    autoload :SafePuts,                   'vli/util/safe_puts'
+  end
+end

data/lib/vli/util/busy.rb

@@ -0,0 +1,59 @@
+module Vli
+  module Util
+    # Utility class which allows blocks of code to be marked as "busy"
+    # with a specified interrupt handler. During busy areas of code, it
+    # is often undesirable for SIGINTs to immediately kill the application.
+    # This class is a helper to cleanly register callbacks to handle this
+    # situation.
+    class Busy
+      @@registered = []
+      @@mutex = Mutex.new
+
+      class << self
+        # Mark a given block of code as a "busy" block of code, which will
+        # register a SIGINT handler for the duration of the block. When a
+        # SIGINT occurs, the `sig_callback` proc will be called. It is up
+        # to the callback to behave properly and exit the application.
+        def busy(sig_callback)
+          register(sig_callback)
+          yield
+        ensure
+          unregister(sig_callback)
+        end
+
+        # Registers a SIGINT handler. This typically is called from {busy}.
+        # Callbacks are only registered once, so calling this multiple times
+        # with the same callback has no consequence.
+        def register(sig_callback)
+          @@mutex.synchronize do
+            registered << sig_callback
+            registered.uniq!
+
+            # Register the handler if this is our first callback.
+            Signal.trap("INT") { fire_callbacks } if registered.length == 1
+          end
+        end
+
+        # Unregisters a SIGINT handler.
+        def unregister(sig_callback)
+          @@mutex.synchronize do
+            registered.delete(sig_callback)
+
+            # Remove the signal trap if no more registered callbacks exist
+            Signal.trap("INT", "DEFAULT") if registered.empty?
+          end
+        end
+
+        # Fires all the registered callbacks.
+        def fire_callbacks
+          registered.reverse.each { |r| r.call }
+        end
+
+        # Helper method to get access to the class variable. This is mostly
+        # exposed for tests. This shouldn't be mucked with directly, since it's
+        # structure may change at any time.
+        def registered; @@registered; end
+      end
+    end
+  end
+end

data/lib/vli/util/hash_with_indifferent_access.rb

@@ -0,0 +1,63 @@
+module Vli
+  module Util
+    # A hash with indifferent access. Mostly taken from Thor/Rails (thanks).
+    # Normally I'm not a fan of using an indifferent access hash since Symbols
+    # are basically memory leaks in Ruby, but since Vli is typically a quick
+    # one-off binary run and it doesn't use too many hash keys where this is
+    # used, the effect should be minimal.
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #
+    class HashWithIndifferentAccess < ::Hash
+      def initialize(hash={}, &block)
+        super(&block)
+
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.collect { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      def key?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :include?, :key?
+      alias_method :has_key?, :key?
+      alias_method :member?, :key?
+
+      protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+    end
+  end
+end

data/lib/vli/util/platform.rb

@@ -0,0 +1,68 @@
+require 'rbconfig'
+require 'tempfile'
+
+module Vli
+  module Util
+    # This class just contains some platform checking code.
+    class Platform
+      class << self
+        def tiger?
+          platform.include?("darwin8")
+        end
+
+        def leopard?
+          platform.include?("darwin9")
+        end
+
+        [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
+          define_method("#{type}?") do
+            platform.include?(type.to_s)
+          end
+        end
+
+        def windows?
+          %W[mingw mswin].each do |text|
+            return true if platform.include?(text)
+          end
+
+          false
+        end
+
+        # Returns boolean noting whether this is a 64-bit CPU. This
+        # is not 100% accurate and there could easily be false negatives.
+        #
+        # @return [Boolean]
+        def bit64?
+          ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
+        end
+
+        # Returns boolean noting whether this is a 32-bit CPU. This
+        # can easily throw false positives since it relies on {#bit64?}.
+        #
+        # @return [Boolean]
+        def bit32?
+          !bit64?
+        end
+
+        # Returns a boolean noting whether the terminal supports color.
+        # output.
+        def terminal_supports_colors?
+          if windows?
+            return ENV.has_key?("ANSICON")
+          end
+
+          true
+        end
+
+        def tar_file_options
+          # create, write only, fail if the file exists, binary if windows
+          File::WRONLY | File::EXCL | File::CREAT | (windows? ? File::BINARY : 0)
+        end
+
+        def platform
+          RbConfig::CONFIG["host_os"].downcase
+        end
+      end
+    end
+  end
+end

data/lib/vli/util/safe_puts.rb

@@ -0,0 +1,31 @@
+module Vli
+  module Util
+    # This module provides a `safe_puts` method which outputs to
+    # the given IO object, and rescues any broken pipe errors and
+    # ignores them. This is useful in cases where you're outputting
+    # to stdout, for example, and the stdout is closed, but you want to
+    # keep running.
+    module SafePuts
+      # Uses `puts` on the given IO object and safely ignores any
+      # Errno::EPIPE.
+      #
+      # @param [String] message Message to output.
+      # @param [Hash] opts Options hash.
+      def safe_puts(message=nil, opts=nil)
+        message ||= ""
+        opts = {
+          :io => $stdout,
+          :printer => :puts
+        }.merge(opts || {})
+
+        begin
+          opts[:io].send(opts[:printer], message)
+        rescue Errno::EPIPE
+          # This is what makes this a `safe` puts.
+          return
+        end
+      end
+    end
+  end
+end
+

data/lib/vli/version.rb

@@ -0,0 +1,3 @@
+module Vli
+  VERSION = "0.0.1"
+end

data/vli.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vli/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vli"
+  gem.version       = Vli::VERSION
+  gem.authors       = ["Tyler Flint"]
+  gem.email         = ["tylerflint@gmail.com"]
+  gem.description   = %q{Vagrant Like Interface is a library of components extracted from the vagrant project to aid in building command line interfaces.}
+  gem.summary       = %q{library of components extracted from the vagrant project}
+  gem.homepage      = "http://github.com/tylerflint/vli"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: vli
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tyler Flint
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-05 00:00:00.000000000 Z
+dependencies: []
+description: Vagrant Like Interface is a library of components extracted from the
+  vagrant project to aid in building command line interfaces.
+email:
+- tylerflint@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vli.rb
+- lib/vli/action.rb
+- lib/vli/action/builder.rb
+- lib/vli/action/env.rb
+- lib/vli/action/env/set.rb
+- lib/vli/action/environment.rb
+- lib/vli/action/runner.rb
+- lib/vli/action/warden.rb
+- lib/vli/command.rb
+- lib/vli/command/base.rb
+- lib/vli/error.rb
+- lib/vli/registry.rb
+- lib/vli/ui.rb
+- lib/vli/util.rb
+- lib/vli/util/busy.rb
+- lib/vli/util/hash_with_indifferent_access.rb
+- lib/vli/util/platform.rb
+- lib/vli/util/safe_puts.rb
+- lib/vli/version.rb
+- vli.gemspec
+homepage: http://github.com/tylerflint/vli
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: library of components extracted from the vagrant project
+test_files: []
+has_rdoc: