bmhatfield-vagrant 1.0.7

data/lib/vagrant/test_helpers.rb

@@ -0,0 +1,154 @@
+module Vagrant
+  # Test helpers provided by Vagrant to allow for plugin developers
+  # to write automated tests for their code. This module simply provides
+  # methods which can be included into any test framework (`test/unit`,
+  # RSpec, Shoulda, etc.)
+  module TestHelpers
+    #------------------------------------------------------------
+    # Environment creation helpers
+    #------------------------------------------------------------
+    # Creates a "vagrant_app" directory in the test tmp folder
+    # which can be used for creating test Vagrant environments.
+    # Returns the root directory of the app. This typically doesn't need
+    # to be called directly unless you're setting up a custom application.
+    # See the examples for common use cases.
+    def vagrant_app(*path)
+      root = tmp_path.join("vagrant_app")
+      FileUtils.rm_rf(root)
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    # Creates a Vagrantfile with the given contents in the given
+    # app directory. If no app directory is specified, then a default
+    # Vagrant app is used.
+    def vagrantfile(*args)
+      path = args.shift.join("Vagrantfile") if Pathname === args.first
+      path ||= vagrant_app("Vagrantfile")
+
+      # Create this box so that it exists
+      vagrant_box("base")
+
+      str  = args.shift || ""
+      File.open(path.to_s, "w") do |f|
+        f.puts "ENV['VAGRANT_HOME'] = '#{home_path}'"
+        f.puts "Vagrant::Config.run do |config|"
+        f.puts "config.vm.base_mac = 'foo' if !config.vm.base_mac"
+        f.puts "config.vm.box = 'base'"
+        f.puts str
+        f.puts "end"
+      end
+
+      path.parent
+    end
+
+    # Creates and _loads_ a Vagrant environment at the given path.
+    # If no path is given, then a default {#vagrantfile} is used.
+    def vagrant_env(*args)
+      path = args.shift if Pathname === args.first
+      path ||= vagrantfile
+      Vagrant::Environment.new(:cwd => path).load!
+    end
+
+    # Creates the folder to contain a vagrant box. This allows for
+    # "fake" boxes to be made with the specified name.
+    #
+    # @param [String] name
+    # @return [Pathname]
+    def vagrant_box(name)
+      result = boxes_path.join(name)
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Returns an instantiated downloader with a mocked tempfile
+    # which can be passed into it.
+    #
+    # @param [Class] klass The downloader class
+    # @return [Array] Returns an array of `downloader` `tempfile`
+    def vagrant_mock_downloader(klass)
+      tempfile = mock("tempfile")
+      tempfile.stubs(:write)
+
+      _, env = action_env
+      [klass.new(env), tempfile]
+    end
+
+    # Returns a blank app (callable) and action environment with the
+    # given vagrant environment. This allows for testing of middlewares.
+    def action_env(v_env = nil)
+      v_env ||= vagrant_env
+      # duplicate the Vagrant::Environment ui and get the default vm object
+      # for the new action environment from the first pair in the vms list
+      opts = {:ui => v_env.ui.dup, :vm => v_env.vms.first.last}
+      app = lambda { |env| }
+      env = Vagrant::Action::Environment.new(opts)
+      env["vagrant.test"] = true
+      [app, env]
+    end
+
+    # Utility method for capturing output streams.
+    # @example Evaluate the output
+    #   output = capture(:stdout){ env.cli("foo") }
+    #   assert_equal "bar", output
+    # @example Silence the output
+    #   silence(:stdout){ env.cli("init") }
+    # @param [:stdout, :stderr] stream The stream to capture
+    # @yieldreturn String
+    # @see https://github.com/wycats/thor/blob/master/spec/spec_helper.rb
+    def capture(stream)
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").string
+      ensure
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+    alias :silence :capture
+
+    #------------------------------------------------------------
+    # Path helpers
+    #------------------------------------------------------------
+    # Path to the tmp directory for the tests.
+    #
+    # @return [Pathname]
+    def tmp_path
+      result = Vagrant.source_root.join("test", "tmp")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the "home" directory for the tests
+    #
+    # @return [Pathname]
+    def home_path
+      result = tmp_path.join("home")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the boxes directory in the home directory
+    #
+    # @return [Pathname]
+    def boxes_path
+      result = home_path.join("boxes")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Cleans all the test temp paths, which includes the boxes path,
+    # home path, etc. This allows for cleaning between tests.
+    def clean_paths
+      FileUtils.rm_rf(tmp_path)
+
+      # Call these methods only to rebuild the directories
+      tmp_path
+      home_path
+      boxes_path
+    end
+  end
+end

data/lib/vagrant/ui.rb

@@ -0,0 +1,168 @@
+require "log4r"
+
+require "vagrant/util/safe_puts"
+
+module Vagrant
+  module UI
+    # Vagrant 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)
+        @logger   = Log4r::Logger.new("vagrant::ui::interface")
+        @resource = resource
+      end
+
+      [:ask, :warn, :error, :info, :success].each do |method|
+        define_method(method) do |message, *opts|
+          # Log normal console messages
+          @logger.info { "#{method}: #{message}" }
+        end
+      end
+
+      [:clear_line, :report_progress].each do |method|
+        # By default do nothing, these aren't logged
+        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/vagrant/util.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    autoload :Busy,                      'vagrant/util/busy'
+    autoload :Counter,                   'vagrant/util/counter'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :SafeExec,                  'vagrant/util/safe_exec'
+    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
+  end
+end

data/lib/vagrant/util/ansi_escape_code_remover.rb

@@ -0,0 +1,34 @@
+module Vagrant
+  module Util
+    module ANSIEscapeCodeRemover
+      # Removes ANSI escape code sequences from the text and returns
+      # it.
+      #
+      # This removes all the ANSI escape codes listed here along with
+      # the escape codes for VT100 terminals:
+      #
+      # http://ascii-table.com/ansi-escape-sequences.php
+      def remove_ansi_escape_codes(text)
+        # An array of regular expressions which match various kinds
+        # of escape sequences. I can't think of a better single regular
+        # expression or any faster way to do this.
+        matchers = [/\e\[\d*[ABCD]/,       # Matches things like \e[4D
+                    /\e\[(\d*;)?\d*[HF]/,  # Matches \e[1;2H or \e[H
+                    /\e\[(s|u|2J|K)/,      # Matches \e[s, \e[2J, etc.
+                    /\e\[=\d*[hl]/,        # Matches \e[=24h
+                    /\e\[\?[1-9][hl]/,     # Matches \e[?2h
+                    /\e\[20[hl]/,          # Matches \e[20l]
+                    /\e[DME78H]/,          # Matches \eD, \eH, etc.
+                    /\e\[[0-2]?[JK]/,      # Matches \e[0J, \e[K, etc.
+                    ]
+
+        # Take each matcher and replace it with emptiness.
+        matchers.each do |matcher|
+          text.gsub!(matcher, "")
+        end
+
+        text
+      end
+    end
+  end
+end

data/lib/vagrant/util/busy.rb

@@ -0,0 +1,59 @@
+module Vagrant
+  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/vagrant/util/counter.rb

@@ -0,0 +1,24 @@
+require 'thread'
+
+module Vagrant
+  module Util
+    # Atomic counter implementation. This is useful for incrementing
+    # a counter which is guaranteed to only be used once in its class.
+    module Counter
+      def get_and_update_counter(name=nil)
+        name ||= :global
+
+        mutex.synchronize do
+          @__counter ||= Hash.new(1)
+          result = @__counter[name]
+          @__counter[name] += 1
+          result
+        end
+      end
+
+      def mutex
+        @__counter_mutex ||= Mutex.new
+      end
+    end
+  end
+end