tnargav 1.3.4 → 1.3.5

data/bin/vagrant

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+
+# Trap interrupts to quit cleanly. This will be overriden at some point
+# by Vagrant. This is made to catch any interrupts while Vagrant is
+# initializing which have historically resulted in stack traces.
+Signal.trap("INT") { exit 1 }
+
+require 'log4r'
+require 'vagrant'
+require 'vagrant/cli'
+require 'vagrant/util/platform'
+
+# Create a logger right away
+logger = Log4r::Logger.new("vagrant::bin::vagrant")
+logger.info("`vagrant` invoked: #{ARGV.inspect}")
+
+# Stdout/stderr should not buffer output
+$stdout.sync = true
+$stderr.sync = true
+
+# These will be the options that are passed to initialze the Vagrant
+# environment.
+opts = {}
+
+# Disable color in a few cases:
+#
+#   * --no-color is anywhere in our arguments
+#   * STDOUT is not a TTY
+#   * The terminal doesn't support colors (Windows)
+#
+if ARGV.include?("--no-color")
+  # Delete the argument from the list so that it doesn't
+  # cause any invalid arguments down the road.
+  ARGV.delete("--no-color")
+
+  opts[:ui_class] = Vagrant::UI::Basic
+elsif !Vagrant::Util::Platform.terminal_supports_colors?
+  opts[:ui_class] = Vagrant::UI::Basic
+elsif !$stdout.tty? && !Vagrant::Util::Platform.cygwin?
+    opts[:ui_class] = Vagrant::UI::Basic
+end
+
+# Also allow users to force colors.
+if ARGV.include?("--color")
+  ARGV.delete("--color")
+  opts[:ui_class] = Vagrant::UI::Colored
+end
+
+# Default to colored output
+opts[:ui_class] ||= Vagrant::UI::Colored
+
+# This is kind of hacky, and I'd love to find a better way to do this, but
+# if we're accessing the plugin interface, we want to NOT load plugins
+# for this run, because they can actually interfere with the function
+# of the plugin interface.
+ARGV.each do |arg|
+  if !arg.start_with?("-")
+    ENV["VAGRANT_NO_PLUGINS"] = "1" if arg == "plugin"
+    break
+  end
+end
+
+# Fast path the version of Vagrant
+if ARGV.include?("-v") || ARGV.include?("--version")
+  puts "Vagrant #{Vagrant::VERSION}"
+  exit 0
+end
+
+env = nil
+begin
+  # Create the environment, which is the cwd of wherever the
+  # `vagrant` command was invoked from
+  logger.debug("Creating Vagrant environment")
+  env = Vagrant::Environment.new(opts)
+
+  if !Vagrant.in_installer?
+    warned = false
+
+    # If we're in a bundler environment, we assume it is for plugin
+    # development and will let the user know that.
+    if defined?(Bundler)
+      require 'bundler/shared_helpers'
+      if Bundler::SharedHelpers.in_bundle?
+        warned = true
+      end
+    end
+
+    # If we're not in the installer, warn.
+    env.ui.warn(I18n.t("vagrant.general.not_in_installer")) if !warned
+  end
+
+  begin
+    # Execute the CLI interface, and exit with the proper error code
+    exit_status = env.cli(ARGV)
+  ensure
+    # Unload the environment so cleanup can be done
+    env.unload
+  end
+
+  # Exit with the exit status from our CLI command
+  exit(exit_status)
+rescue Vagrant::Errors::VagrantError => e
+  logger.error("Vagrant experienced an error! Details:")
+  logger.error(e.inspect)
+  logger.error(e.message)
+  logger.error(e.backtrace.join("\n"))
+
+  if env
+    opts = { :prefix => false }
+    env.ui.error e.message, opts if e.message
+  else
+    $stderr.puts "Vagrant failed to initialize at a very early stage:\n\n"
+    $stderr.puts e.message
+  end
+
+  exit e.status_code if e.respond_to?(:status_code)
+  exit 999 # An error occurred with no status code defined
+end

data/config/default.rb

@@ -0,0 +1,34 @@
+Vagrant.configure("2") do |config|
+  config.vagrant.host = :detect
+
+  config.ssh.forward_agent = false
+  config.ssh.forward_x11 = false
+  config.ssh.guest_port = 22
+  config.ssh.keep_alive = true
+  config.ssh.shell = "bash -l"
+
+  config.ssh.default.username = "vagrant"
+
+  config.vm.usable_port_range = (2200..2250)
+  config.vm.box_url = nil
+  config.vm.base_mac = nil
+  config.vm.boot_timeout = 300
+  config.vm.graceful_halt_timeout = 60
+
+  # Share SSH locally by default
+  config.vm.network :forwarded_port,
+    guest: 22,
+    host: 2222,
+    host_ip: "127.0.0.1",
+    id: "ssh",
+    auto_correct: true
+
+  # Share the root folder. This can then be overridden by
+  # other Vagrantfiles, if they wish.
+  config.vm.synced_folder ".", "/vagrant"
+
+  config.nfs.map_uid = :auto
+  config.nfs.map_gid = :auto
+
+  config.package.name = 'package.box'
+end

data/keys/README.md

@@ -0,0 +1,10 @@
+# Insecure Keypair
+
+These keys are the "insecure" public/private keypair we offer to
+[base box creators](http://docs.vagrantup.com/v1/docs/base_boxes.html) for use in their base boxes so that
+vagrant installations can automatically SSH into the boxes.
+
+If you're working with a team or company or with a custom box and
+you want more secure SSH, you should create your own keypair
+and configure the private key in the Vagrantfile with
+`config.ssh.private_key_path`

data/keys/vagrant

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzI
+w+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoP
+kcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2
+hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NO
+Td0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcW
+yLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQIBIwKCAQEA4iqWPJXtzZA68mKd
+ELs4jJsdyky+ewdZeNds5tjcnHU5zUYE25K+ffJED9qUWICcLZDc81TGWjHyAqD1
+Bw7XpgUwFgeUJwUlzQurAv+/ySnxiwuaGJfhFM1CaQHzfXphgVml+fZUvnJUTvzf
+TK2Lg6EdbUE9TarUlBf/xPfuEhMSlIE5keb/Zz3/LUlRg8yDqz5w+QWVJ4utnKnK
+iqwZN0mwpwU7YSyJhlT4YV1F3n4YjLswM5wJs2oqm0jssQu/BT0tyEXNDYBLEF4A
+sClaWuSJ2kjq7KhrrYXzagqhnSei9ODYFShJu8UWVec3Ihb5ZXlzO6vdNQ1J9Xsf
+4m+2ywKBgQD6qFxx/Rv9CNN96l/4rb14HKirC2o/orApiHmHDsURs5rUKDx0f9iP
+cXN7S1uePXuJRK/5hsubaOCx3Owd2u9gD6Oq0CsMkE4CUSiJcYrMANtx54cGH7Rk
+EjFZxK8xAv1ldELEyxrFqkbE4BKd8QOt414qjvTGyAK+OLD3M2QdCQKBgQDtx8pN
+CAxR7yhHbIWT1AH66+XWN8bXq7l3RO/ukeaci98JfkbkxURZhtxV/HHuvUhnPLdX
+3TwygPBYZFNo4pzVEhzWoTtnEtrFueKxyc3+LjZpuo+mBlQ6ORtfgkr9gBVphXZG
+YEzkCD3lVdl8L4cw9BVpKrJCs1c5taGjDgdInQKBgHm/fVvv96bJxc9x1tffXAcj
+3OVdUN0UgXNCSaf/3A/phbeBQe9xS+3mpc4r6qvx+iy69mNBeNZ0xOitIjpjBo2+
+dBEjSBwLk5q5tJqHmy/jKMJL4n9ROlx93XS+njxgibTvU6Fp9w+NOFD/HvxB3Tcz
+6+jJF85D5BNAG3DBMKBjAoGBAOAxZvgsKN+JuENXsST7F89Tck2iTcQIT8g5rwWC
+P9Vt74yboe2kDT531w8+egz7nAmRBKNM751U/95P9t88EDacDI/Z2OwnuFQHCPDF
+llYOUI+SpLJ6/vURRbHSnnn8a/XG+nzedGH5JGqEJNQsz+xT2axM0/W/CRknmGaJ
+kda/AoGANWrLCz708y7VYgAtW2Uf1DPOIYMdvo6fxIB5i9ZfISgcJ/bbCUkFrhoH
++vq/5CIWxCPp0f85R4qxxQ5ihxJ0YDQT9Jpx4TMss4PSavPaBH3RXow5Ohe+bYoQ
+NE5OgEXk2wVfZczCZpigBKbKZHNYcelXtTt/nP3rsCuGcM4h53s=
+-----END RSA PRIVATE KEY-----

data/keys/vagrant.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key

data/lib/vagrant.rb

@@ -0,0 +1,265 @@
+require 'log4r'
+
+# Enable logging if it is requested. We do this before
+# anything else so that we can setup the output before
+# any logging occurs.
+if ENV["VAGRANT_LOG"] && ENV["VAGRANT_LOG"] != ""
+  # Require Log4r and define the levels we'll be using
+  require 'log4r/config'
+  Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+  level = nil
+  begin
+    level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+  rescue NameError
+    # This means that the logging constant wasn't found,
+    # which is fine. We just keep `level` as `nil`. But
+    # we tell the user.
+    level = nil
+  end
+
+  # Some constants, such as "true" resolve to booleans, so the
+  # above error checking doesn't catch it. This will check to make
+  # sure that the log level is an integer, as Log4r requires.
+  level = nil if !level.is_a?(Integer)
+
+  if !level
+    # We directly write to stderr here because the VagrantError system
+    # is not setup yet.
+    $stderr.puts "Invalid VAGRANT_LOG level is set: #{ENV["VAGRANT_LOG"]}"
+    $stderr.puts ""
+    $stderr.puts "Please use one of the standard log levels: debug, info, warn, or error"
+    exit 1
+  end
+
+  # Set the logging level on all "vagrant" namespaced
+  # logs as long as we have a valid level.
+  if level
+    logger = Log4r::Logger.new("vagrant")
+    logger.outputters = Log4r::Outputter.stderr
+    logger.level = level
+    logger = nil
+  end
+end
+
+require 'json'
+require 'pathname'
+require 'stringio'
+
+require 'childprocess'
+require 'i18n'
+
+# OpenSSL must be loaded here since when it is loaded via `autoload`
+# there are issues with ciphers not being properly loaded.
+require 'openssl'
+
+# Always make the version available
+require 'vagrant/version'
+global_logger = Log4r::Logger.new("vagrant::global")
+global_logger.info("Vagrant version: #{Vagrant::VERSION}")
+
+# We need these components always so instead of an autoload we
+# just require them explicitly here.
+require "vagrant/registry"
+
+module Vagrant
+  autoload :Action,        'vagrant/action'
+  autoload :BatchAction,   'vagrant/batch_action'
+  autoload :Box,           'vagrant/box'
+  autoload :BoxCollection, 'vagrant/box_collection'
+  autoload :CLI,           'vagrant/cli'
+  autoload :Command,       'vagrant/command'
+  autoload :Config,        'vagrant/config'
+  autoload :Driver,        'vagrant/driver'
+  autoload :Environment,   'vagrant/environment'
+  autoload :Errors,        'vagrant/errors'
+  autoload :Guest,         'vagrant/guest'
+  autoload :Hosts,         'vagrant/hosts'
+  autoload :Machine,       'vagrant/machine'
+  autoload :MachineState,  'vagrant/machine_state'
+  autoload :Plugin,        'vagrant/plugin'
+  autoload :UI,            'vagrant/ui'
+  autoload :Util,          'vagrant/util'
+
+  # These are the various plugin versions and their components in
+  # a lazy loaded Hash-like structure.
+  PLUGIN_COMPONENTS = Registry.new.tap do |c|
+    c.register(:"1")                  { Plugin::V1::Plugin }
+    c.register([:"1", :command])      { Plugin::V1::Command }
+    c.register([:"1", :communicator]) { Plugin::V1::Communicator }
+    c.register([:"1", :config])       { Plugin::V1::Config }
+    c.register([:"1", :guest])        { Plugin::V1::Guest }
+    c.register([:"1", :host])         { Plugin::V1::Host }
+    c.register([:"1", :provider])     { Plugin::V1::Provider }
+    c.register([:"1", :provisioner])  { Plugin::V1::Provisioner }
+
+    c.register(:"2")                  { Plugin::V2::Plugin }
+    c.register([:"2", :command])      { Plugin::V2::Command }
+    c.register([:"2", :communicator]) { Plugin::V2::Communicator }
+    c.register([:"2", :config])       { Plugin::V2::Config }
+    c.register([:"2", :guest])        { Plugin::V2::Guest }
+    c.register([:"2", :host])         { Plugin::V2::Host }
+    c.register([:"2", :provider])     { Plugin::V2::Provider }
+    c.register([:"2", :provisioner])  { Plugin::V2::Provisioner }
+  end
+
+  # This returns a true/false showing whether we're running from the
+  # environment setup by the Vagrant installers.
+  #
+  # @return [Boolean]
+  def self.in_installer?
+    !!ENV["VAGRANT_INSTALLER_ENV"]
+  end
+
+  # The source root is the path to the root directory of
+  # the Vagrant gem.
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+  end
+
+  # Configure a Vagrant environment. The version specifies the version
+  # of the configuration that is expected by the block. The block, based
+  # on that version, configures the environment.
+  #
+  # Note that the block isn't run immediately. Instead, the configuration
+  # block is stored until later, and is run when an environment is loaded.
+  #
+  # @param [String] version Version of the configuration
+  def self.configure(version, &block)
+    Config.run(version, &block)
+  end
+
+  # This checks if a plugin with the given name is installed. This can
+  # be used from the Vagrantfile to easily branch based on plugin
+  # availability.
+  def self.has_plugin?(name)
+    plugin("2").manager.registered.any? { |plugin| plugin.name == name }
+  end
+
+  # Returns a superclass to use when creating a plugin for Vagrant.
+  # Given a specific version, this returns a proper superclass to use
+  # to register plugins for that version.
+  #
+  # Optionally, if you give a specific component, then it will return
+  # the proper superclass for that component as well.
+  #
+  # Plugins and plugin components should subclass the classes returned by
+  # this method. This method lets Vagrant core control these superclasses
+  # and change them over time without affecting plugins. For example, if
+  # the V1 superclass happens to be "Vagrant::V1," future versions of
+  # Vagrant may move it to "Vagrant::Plugins::V1" and plugins will not be
+  # affected.
+  #
+  # @param [String] version
+  # @param [String] component
+  # @return [Class]
+  def self.plugin(version, component=nil)
+    # Build up the key and return a result
+    key    = version.to_s.to_sym
+    key    = [key, component.to_s.to_sym] if component
+    result = PLUGIN_COMPONENTS.get(key)
+
+    # If we found our component then we return that
+    return result if result
+
+    # If we didn't find a result, then raise an exception, depending
+    # on if we got a component or not.
+    raise ArgumentError, "Plugin superclass not found for version/component: " +
+      "#{version} #{component}"
+  end
+
+  # This should be used instead of Ruby's built-in `require` in order to
+  # load a Vagrant plugin. This will load the given plugin by first doing
+  # a normal `require`, giving a nice error message if things go wrong,
+  # and second by verifying that a Vagrant plugin was actually defined in
+  # the process.
+  #
+  # @param [String] name Name of the plugin to load.
+  def self.require_plugin(name)
+    if ENV["VAGRANT_NO_PLUGINS"]
+      logger = Log4r::Logger.new("vagrant::root")
+      logger.warn("VAGRANT_NO_PLUGINS is set, not loading 3rd party plugin: #{name}")
+      return
+    end
+
+    # Redirect stdout/stderr so that we can output it in our own way.
+    previous_stderr = $stderr
+    previous_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+
+    # Attempt the normal require
+    begin
+      require name
+    rescue Exception => e
+      # Since this is a rare case, we create a one-time logger here
+      # in order to output the error
+      logger = Log4r::Logger.new("vagrant::root")
+      logger.error("Failed to load plugin: #{name}")
+      logger.error(" -- Error: #{e.inspect}")
+      logger.error(" -- Backtrace:")
+      logger.error(e.backtrace.join("\n"))
+
+      # If it is a LoadError we first try to see if it failed loading
+      # the top-level entrypoint. If so, then we report a different error.
+      if e.is_a?(LoadError)
+        # Parse the message in order to get what failed to load, and
+        # add some extra protection around if the message is different.
+        parts = e.to_s.split(" -- ", 2)
+        if parts.length == 2 && parts[1] == name
+          raise Errors::PluginLoadError, :plugin => name
+        end
+      end
+
+      # Get the string data out from the stdout/stderr captures
+      stderr = $stderr.string
+      stdout = $stdout.string
+      if !stderr.empty? || !stdout.empty?
+        raise Errors::PluginLoadFailedWithOutput,
+          :plugin => name,
+          :stderr => stderr,
+          :stdout => stdout
+      end
+
+      # And raise an error itself
+      raise Errors::PluginLoadFailed,
+        :plugin => name
+    end
+  ensure
+    $stderr = previous_stderr if previous_stderr
+    $stdout = previous_stdout if previous_stdout
+  end
+end
+
+# Default I18n to load the en locale
+I18n.load_path << File.expand_path("templates/locales/en.yml", Vagrant.source_root)
+
+# A lambda that knows how to load plugins from a single directory.
+plugin_load_proc = lambda do |directory|
+  # We only care about directories
+  next false if !directory.directory?
+
+  # If there is a plugin file in the top-level directory, then load
+  # that up.
+  plugin_file = directory.join("plugin.rb")
+  if plugin_file.file?
+    global_logger.debug("Loading core plugin: #{plugin_file}")
+    load(plugin_file)
+    next true
+  end
+end
+
+# Go through the `plugins` directory and attempt to load any plugins. The
+# plugins are allowed to be in a directory in `plugins` or at most one
+# directory deep within the plugins directory. So a plugin can be at
+# `plugins/foo` or also at `plugins/foo/bar`, but no deeper.
+Vagrant.source_root.join("plugins").children(true).each do |directory|
+  # Ignore non-directories
+  next if !directory.directory?
+
+  # Load from this directory, and exit if we successfully loaded a plugin
+  next if plugin_load_proc.call(directory)
+
+  # Otherwise, attempt to load from sub-directories
+  directory.children(true).each(&plugin_load_proc)
+end

data/plugins/README.md

@@ -0,0 +1,5 @@
+# Vagrant Core Plugins
+
+These are plugins that ship with Vagrant. Vagrant core uses its own
+plugin system to power a lot of the core pieces that ship with Vagrant.
+Each plugin will have its own README which explains its specific role.

data/tasks/acceptance.rake

@@ -0,0 +1,113 @@
+require 'digest/sha1'
+require 'net/http'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+require 'childprocess'
+
+require 'vagrant/util/file_checksum'
+
+namespace :acceptance do
+  desc "Downloads the boxes required for running the acceptance tests."
+  task :boxes, :directory do |t, args|
+    # Create the directory where the boxes will be downloaded
+    box_dir = Pathname.new(args[:directory] || File.expand_path("../../boxes", __FILE__))
+    box_dir.mkpath
+    puts "Boxes will be placed in: #{box_dir}"
+
+    # Load the required boxes
+    boxes = YAML.load_file(File.expand_path("../../test/config/acceptance_boxes.yml", __FILE__))
+
+    boxes.each do |box|
+      puts "Box: #{box["name"]}"
+      box_file = box_dir.join("#{box["name"]}.box")
+      checksum = FileChecksum.new(box_file, Digest::SHA1)
+
+      # If the box exists, we need to check the checksum and determine if we need
+      # to redownload the file.
+      if box_file.exist?
+        print "Box exists, checking SHA1 sum... "
+        if checksum.checksum == box["checksum"]
+          print "OK\n"
+          next
+        else
+          print "FAIL\n"
+        end
+      end
+
+      # Download the file. Note that this has no error checking and just uses
+      # pure net/http. There could be a better way.
+      puts "Downloading: #{box["url"]}"
+      destination = box_file.open("wb")
+      uri = URI.parse(box["url"])
+      Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.request_get(uri.request_uri) do |response|
+          total = response.content_length
+          progress = 0
+          count = 0
+
+          response.read_body do |segment|
+            # Really elementary progress meter
+            progress += segment.length
+            count += 1
+            puts "Progress: #{(progress.to_f / total.to_f) * 100}%" if count % 300 == 0
+
+            # Write out to the destination file
+            destination.write(segment)
+          end
+        end
+      end
+
+      destination.close
+
+      # Check the checksum of the new file to verify that it
+      # downloaded properly. This shouldn't happen, but it can!
+      if checksum.checksum != box["checksum"]
+        puts "Checksum didn't match! Download was corrupt!"
+        abort
+      end
+    end
+  end
+
+  desc "Generates the configuration for acceptance tests from current source."
+  task :config, :box_dir do |t, args|
+    require File.expand_path("../../lib/vagrant/version", __FILE__)
+    require File.expand_path('../../test/support/tempdir', __FILE__)
+
+    # Get the directory for the boxes
+    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../boxes", __FILE__))
+
+    # Generate the binstubs for the Vagrant binary
+    tempdir = Tempdir.new
+    process = ChildProcess.build("bundle", "install", "--binstubs", tempdir.path)
+    process.io.inherit!
+    process.start
+    process.poll_for_exit(64000)
+    if process.exit_code != 0
+      # Bundle install failed...
+      puts "Bundle install failed!"
+      abort
+    end
+
+    # Generate the actual configuration
+    config = {
+      "vagrant_path" => File.join(tempdir.path, "vagrant"),
+      "vagrant_version" => Vagrant::VERSION,
+      "env" => {
+        "BUNDLE_GEMFILE" => File.expand_path("../../Gemfile", __FILE__)
+      },
+      "box_directory" => box_dir.to_s
+    }
+
+    File.open("acceptance_config.yml", "w+") do |f|
+      f.write(YAML.dump(config))
+    end
+
+    puts <<-OUTPUT
+Acceptance test configuration is now in this directory in
+"acceptance_config.yml." Set your ACCEPTANCE_CONFIG environmental
+variable to this file and run any of the acceptance tests now.
+OUTPUT
+  end
+end

data/tasks/bundler.rake

@@ -0,0 +1,3 @@
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks

data/tasks/test.rake

@@ -0,0 +1,20 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+namespace :test do
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "unit"
+    t.pattern = "test/unit/**/*_test.rb"
+  end
+
+  Rake::TestTask.new do |t|
+    t.name = "unit_old"
+    t.libs << "test/unit_legacy"
+    t.pattern = "test/unit_legacy/**/*_test.rb"
+  end
+
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "acceptance"
+    t.pattern = "test/acceptance/**/*_test.rb"
+  end
+end

data/templates/package_Vagrantfile.erb

@@ -0,0 +1,11 @@
+Vagrant::Config.run do |config|
+  # This Vagrantfile is auto-generated by `vagrant package` to contain
+  # the MAC address of the box. Custom configuration should be placed in
+  # the actual `Vagrantfile` in this box.
+  config.vm.base_mac = "<%= base_mac %>"
+end
+
+# Load include vagrant file if it exists after the auto-generated
+# so it can override any of the settings
+include_vagrantfile = File.expand_path("../include/_Vagrantfile", __FILE__)
+load include_vagrantfile if File.exist?(include_vagrantfile)

data/templates/rgloader.rb

@@ -0,0 +1,9 @@
+# This file loads the proper rgloader/loader.rb file that comes packaged
+# with Vagrant so that encoded files can properly run with Vagrant.
+
+if ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"]
+  require File.expand_path(
+    "rgloader/loader", ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"])
+else
+  raise "Encoded files can't be read outside of the Vagrant installer."
+end

data/tnargav.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec-mocks", "~> 2.11.0"
 
   root_path      = File.dirname(__FILE__)
-  all_files      = Dir.chdir(root_path) { Dir.glob("**/{bin,config,keys,lib,plugins,tasks,templates,test}") }
+  all_files      = Dir.chdir(root_path) { Dir.glob("{bin,config,keys,lib,plugins,tasks,templates,test}/**") }
   all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
   all_files     += %w(CHANGELOG.md CONTRIBUTING.md Gemfile LICENSE README.md tnargav.gemspec)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tnargav
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.5
   prerelease: 
 platform: ruby
 authors:
@@ -225,10 +225,23 @@ description: Vagrant is a tool for building and distributing virtualized develop
 email:
 - mitchell.hashimoto@gmail.com
 - john.m.bender@gmail.com
-executables: []
+executables:
+- vagrant
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/vagrant
+- config/default.rb
+- keys/README.md
+- keys/vagrant
+- keys/vagrant.pub
+- lib/vagrant.rb
+- plugins/README.md
+- tasks/acceptance.rake
+- tasks/bundler.rake
+- tasks/test.rake
+- templates/package_Vagrantfile.erb
+- templates/rgloader.rb
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile