vagrant 1.0.7 → 2.4.4

data/Gemfile

@@ -1,3 +1,12 @@
-source "http://rubygems.org"
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+source "https://rubygems.org"
 
 gemspec
+
+if File.exist?(File.expand_path("../../vagrant-spec", __FILE__))
+  gem 'vagrant-spec', path: "../vagrant-spec"
+else
+  gem 'vagrant-spec', git: "https://github.com/hashicorp/vagrant-spec.git", branch: :main
+end

data/LICENSE

@@ -1,21 +1,92 @@
-The MIT License
-
-Copyright (c) 2010-2012Mitchell Hashimoto and John Bender
-
-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.
+License text copyright (c) 2020 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             HashiCorp, Inc.
+Licensed Work:        Vagrant 2.4.3 or later. The Licensed Work is (c) 2024
+                      HashiCorp, Inc.
+Additional Use Grant: You may make production use of the Licensed Work, provided
+                      Your use does not include offering the Licensed Work to third
+                      parties on a hosted or embedded basis in order to compete with
+                      HashiCorp’s paid version(s) of the Licensed Work. For purposes
+                      of this license:
+
+                      A "competitive offering" is a Product that is offered to third
+                      parties on a paid basis, including through paid support
+                      arrangements, that significantly overlaps with the capabilities
+                      of HashiCorp's paid version(s) of the Licensed Work. If Your
+                      Product is not a competitive offering when You first make it
+                      generally available, it will not become a competitive offering
+                      later due to HashiCorp releasing a new version of the Licensed
+                      Work with additional capabilities. In addition, Products that
+                      are not provided on a paid basis are not competitive.
+
+                      "Product" means software that is offered to end users to manage
+                      in their own environments or offered as a service on a hosted
+                      basis.
+
+                      "Embedded" means including the source code or executable code
+                      from the Licensed Work in a competitive offering. "Embedded"
+                      also means packaging the competitive offering in such a way
+                      that the Licensed Work must be accessed or downloaded for the
+                      competitive offering to operate.
+
+                      Hosting or using the Licensed Work(s) for internal purposes
+                      within an organization is not considered a competitive
+                      offering. HashiCorp considers your organization to include all
+                      of your affiliates under common control.
+
+                      For binding interpretive guidance on using HashiCorp products
+                      under the Business Source License, please visit our FAQ.
+                      (https://www.hashicorp.com/license-faq)
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       MPL 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact licensing@hashicorp.com.
+
+Notice
+
+Business Source License 1.1
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.

data/README.md

@@ -1,91 +1,56 @@
 # Vagrant
 
-* Website: [http://vagrantup.com](http://vagrantup.com)
-* Source: [https://github.com/mitchellh/vagrant](https://github.com/mitchellh/vagrant)
-* IRC: `#vagrant` on Freenode
-* Mailing list: [Google Groups](http://groups.google.com/group/vagrant-up)
+- Website: [https://www.vagrantup.com/](https://www.vagrantup.com/)
+- Source: [https://github.com/hashicorp/vagrant](https://github.com/hashicorp/vagrant)
+- HashiCorp Discuss: [https://discuss.hashicorp.com/c/vagrant/24](https://discuss.hashicorp.com/c/vagrant/24)
 
-Vagrant is a tool for building and distributing virtualized development environments.
+Vagrant is a tool for building and distributing development environments.
 
-By providing automated creation and provisioning of virtual machines using [Oracle’s VirtualBox](http://www.virtualbox.org),
-Vagrant provides the tools to create and configure lightweight, reproducible, and portable
-virtual environments. For more information, see the part of the getting started guide
-on “[Why Vagrant?](http://vagrantup.com/docs/getting-started/why.html)”
+Development environments managed by Vagrant can run on local virtualized
+platforms such as VirtualBox or VMware, in the cloud via AWS or OpenStack,
+or in containers such as with Docker or raw LXC.
+
+Vagrant provides the framework and configuration format to create and
+manage complete portable development environments. These development
+environments can live on your computer or in the cloud, and are portable
+between Windows, Mac OS X, and Linux.
 
 ## Quick Start
 
-First, make sure your development machine has [VirtualBox](http://www.virtualbox.org)
-installed. The setup from that point forward is very easy, since Vagrant is simply
-a rubygem.
+Package dependencies: Vagrant requires `bsdtar` and `curl` to be available on
+your system PATH to run successfully.
+
+For the quick-start, we'll bring up a development machine on
+[VirtualBox](https://www.virtualbox.org/) because it is free and works
+on all major platforms. Vagrant can, however, work with almost any
+system such as [OpenStack](https://www.openstack.org/), [VMware](https://www.vmware.com/), [Docker](https://docs.docker.com/), etc.
 
-    gem install vagrant
+First, make sure your development machine has
+[VirtualBox](https://www.virtualbox.org/)
+installed. After this,
+[download and install the appropriate Vagrant package for your OS](https://www.vagrantup.com/downloads.html).
 
 To build your first virtual environment:
 
-    vagrant init lucid32 http://files.vagrantup.com/lucid32.box
+    vagrant init hashicorp/bionic64
     vagrant up
 
 Note: The above `vagrant up` command will also trigger Vagrant to download the
-`lucid32` box via the specified URL. Vagrant only does this if it detects that
+`bionic64` box via the specified URL. Vagrant only does this if it detects that
 the box doesn't already exist on your system.
 
 ## Getting Started Guide
 
-To learn how to build a fully functional rails development environment, view the
-[getting started guide](http://vagrantup.com/docs/getting-started/index.html).
+To learn how to build a fully functional development environment, follow the
+[getting started guide](https://www.vagrantup.com/docs/getting-started).
 
-## Installing the Gem from Git
+## Installing from Source
 
-If you want the bleeding edge version of Vagrant, we try to keep master pretty stable
-and you're welcome to give it a shot. The following is an example showing how to do this:
-
-    rake install
+If you want the bleeding edge version of Vagrant, we try to keep main pretty stable
+and you're welcome to give it a shot. Please review the installation page [here](https://www.vagrantup.com/docs/installation/source).
 
 ## Contributing to Vagrant
 
-### Dependencies and Unit Tests
-
-To hack on vagrant, you'll need [bundler](http://github.com/carlhuda/bundler) which can
-be installed with a simple `gem install bundler`. Afterwords, do the following:
-
-    bundle install
-    rake
-
-This will run the unit test suite, which should come back all green! Then you're good to go!
-
-If you want to run Vagrant without having to install the gem, you may use `bundle exec`,
-like so:
-
-    bundle exec bin/vagrant help
-
-### Acceptance Tests
-
-Vagrant also comes with an acceptance test suite which runs the system
-end-to-end, without mocking out any dependencies. Note that this test
-suite is **extremely slow**, with the test suite taking hours on even
-a decent system. A CI will be setup in due time to run these tests
-automatically. However, it is still useful to know how to run these
-tests since it is often useful to run a single test if you're working
-on a specific feature.
-
-The acceptance tests have absolutely _zero_ dependence on the Vagrant
-source. Instead, an external configuration file must be used to give
-the acceptance tests some parameters (such as what Vagrant version is
-running, where the Vagrant `vagrant` binary is, etc.). If you want to
-run acceptance tests against source, or just want to see an example of
-this file, you can generate it automatically for the source code:
-
-    rake acceptance:config
-
-This will drop an `acceptance_config.yml` file in your working directory.
-You can then run a specific acceptance test like so:
-
-    ACCEPTANCE_CONFIG=./acceptance_config.yml ruby test/acceptance/version_test.rb
-
-That's it!
-
-If you're developing an acceptance test and you're unsure why things
-might be failing, you can also view log output for the acceptance tests,
-which can be very verbose but are a great help in finding bugs:
+Please take time to read the [HashiCorp Community Guidelines](https://www.hashicorp.com/community-guidelines) and the [Vagrant Contributing Guide](https://github.com/hashicorp/vagrant/blob/main/.github/CONTRIBUTING.md).
 
-    ACCEPTANCE_LOGGING=debug ACCEPTANCE_CONFIG=./acceptance_config.yml ruby test/acceptance/version_test.rb
+Then you're good to go!

data/RELEASE.md

@@ -0,0 +1,11 @@
+# Releasing Vagrant
+
+This documents how to release Vagrant. Various steps in this document will
+require privileged access to private systems, so this document is only
+targeted at Vagrant core members who have the ability to cut a release.
+
+1. Go to the [release initiator workflow](https://github.com/hashicorp/vagrant/actions/workflows/initiate-release.yml)
+
+1. Trigger a new run with the version to be released (it should not include a `v` prefix, for example: `1.0.0`)
+
+1. After release is complete, update [Checkpoint](https://checkpoint.hashicorp.com/control)

data/Rakefile

@@ -1,11 +1,15 @@
 require 'rubygems'
 require 'bundler/setup'
+require "rake/extensiontask"
 
 # Immediately sync all stdout so that tools like buildbot can
 # immediately load in the output.
 $stdout.sync = true
 $stderr.sync = true
 
+Rake::ExtensionTask.new "vagrant/vagrant_ssl" do |ext|
+end
+
 # Load all the rake tasks from the "tasks" folder. This folder
 # allows us to nicely separate rake tasks into individual files
 # based on their role, which makes development and debugging easier
@@ -15,4 +19,4 @@ Dir["#{task_dir}/**/*.rake"].each do |task_file|
   load task_file
 end
 
-task :default => "test:unit"
+task default: "test:unit"

data/Vagrantfile

@@ -0,0 +1,31 @@
+# This Vagrantfile can be used to develop Vagrant. Note that VirtualBox
+# doesn't run in VirtualBox so you can't actually _run_ Vagrant within
+# the VM created by this Vagrantfile, but you can use it to develop the
+# Ruby, run unit tests, etc.
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "hashicorp/bionic64"
+  config.vm.hostname = "vagrant"
+  config.ssh.shell = "bash -c 'BASH_ENV=/etc/profile exec bash'"
+
+  ["vmware_desktop", "virtualbox", "hyperv"].each do |provider|
+    config.vm.provider provider do |v, override|
+      v.memory = "2048"
+    end
+  end
+
+  # We split apart `install_rvm` from `setup_tests` because rvm says to
+  # logout and log back in just after installing RVM.
+  # https://github.com/rvm/ubuntu_rvm#3-reboot
+  config.vm.provision "shell", path: "scripts/install_rvm"
+
+  config.vm.provision "shell", path: "scripts/setup_tests"
+
+  config.push.define "www", strategy: "local-exec" do |push|
+    push.script = "scripts/website_push_www.sh"
+  end
+
+  config.push.define "docs", strategy: "local-exec" do |push|
+    push.script = "scripts/website_push_docs.sh"
+  end
+end

data/bin/vagrant

@@ -1,60 +1,270 @@
 #!/usr/bin/env ruby
-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}")
+# Trap interrupts to quit cleanly. This will be overridden 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") { abort }
+
+# Disable exception reporting by default if available
+if Thread.respond_to?(:report_on_exception=)
+  Thread.report_on_exception = false
+end
+
+# Split arguments by "--" if its there, we'll recombine them later
+argv = ARGV.dup
+argv_extra = []
+
+# These will be the options that are passed to initialize the Vagrant
+# environment.
+opts = {}
+
+if idx = argv.index("--")
+  argv_extra = argv.slice(idx+1, argv.length-2)
+  argv = argv.slice(0, idx)
+end
+
+require_relative "../lib/vagrant/version"
+# Fast path the version of Vagrant
+if argv.include?("-v") || argv.include?("--version")
+  puts "Vagrant #{Vagrant::VERSION}"
+  exit 0
+end
+
+# Disable plugin loading for commands where plugins are not required. This will
+# also disable loading of the Vagrantfile if it available as the environment
+# is not required for these commands
+argv.each_index do |i|
+  arg = argv[i]
+
+  if !arg.start_with?("-")
+    if arg == "box" && argv[i+1] == "list"
+      opts[:vagrantfile_name] = ""
+      ENV['VAGRANT_NO_PLUGINS'] = "1"
+    end
+
+    # Do not load plugins when performing plugin operations
+    if arg == "plugin"
+      if argv.none?{|a| a == "--local" } && !ENV["VAGRANT_LOCAL_PLUGINS_LOAD"]
+        opts[:vagrantfile_name] = ""
+      end
+      ENV['VAGRANT_NO_PLUGINS'] = "1"
+      # Only initialize plugins when listing installed plugins
+      if argv[i+1] != "list"
+        ENV['VAGRANT_DISABLE_PLUGIN_INIT'] = "1"
+      end
+    end
+
+    break
+  end
+end
+
+# Set logging level to `debug`. This is done before loading 'vagrant', as it
+# sets up the logging system.
+if argv.include?("--debug")
+  argv.delete("--debug")
+  ENV["VAGRANT_LOG"] = "debug"
+end
+
+# Enable log timestamps if requested
+if argv.include?("--timestamp")
+  argv.delete("--timestamp")
+  ENV["VAGRANT_LOG_TIMESTAMP"] = "1"
+end
+
+# Convenience flag to enable debug with timestamps
+if argv.include?("--debug-timestamp")
+  argv.delete("--debug-timestamp")
+  ENV["VAGRANT_LOG"] = "debug"
+  ENV["VAGRANT_LOG_TIMESTAMP"] = "1"
+end
 
 # 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 = {}
+# Before we start activate all our dependencies
+# so we can provide correct resolutions later
+builtin_specs = []
+
+vagrant_spec = Gem::Specification.find_all_by_name("vagrant").detect do |spec|
+  spec.version == Gem::Version.new(Vagrant::VERSION)
+end
+
+dep_activator = proc do |spec|
+  spec.runtime_dependencies.each do |dep|
+    gem(dep.name, *dep.requirement.as_list)
+    dep_spec = Gem::Specification.find_all_by_name(dep.name).detect(&:activated?)
+    if dep_spec
+      builtin_specs << dep_spec
+      dep_activator.call(dep_spec)
+    end
+  end
+end
 
-# Disable color if the proper argument was passed or if we're
-# on Windows since the default Windows terminal doesn't support
-# colors.
-if ARGV.include?("--no-color") || !$stdout.tty? || !Vagrant::Util::Platform.terminal_supports_colors?
-  # 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
-else
-  opts[:ui_class] = Vagrant::UI::Colored
+if vagrant_spec
+  dep_activator.call(vagrant_spec)
 end
 
 env = nil
 begin
+  require 'vagrant'
+  require 'vagrant/bundler'
+  require 'vagrant/cli'
+  require 'vagrant/util/platform'
+  require 'vagrant/util/experimental'
+
+  # Set our list of builtin specs
+  Vagrant::Bundler.instance.builtin_specs = builtin_specs
+
+  # Schedule the cleanup of things
+  at_exit(&Vagrant::Bundler.instance.method(:deinit))
+
+  # If this is not a pre-release disable verbose output
+  if !Vagrant.prerelease?
+    $VERBOSE = nil
+  end
+
+  # Add any option flags defined within this file here
+  # so they are automatically propagated to all commands
+  Vagrant.add_default_cli_options(proc { |o|
+    o.on("--[no-]color", "Enable or disable color output")
+    o.on("--machine-readable", "Enable machine readable output")
+    o.on("-v", "--version", "Display Vagrant version")
+    o.on("--debug", "Enable debug output")
+    o.on("--timestamp", "Enable timestamps on log output")
+    o.on("--debug-timestamp", "Enable debug output with timestamps")
+    o.on("--no-tty", "Enable non-interactive output")
+  })
+
+  # Create a logger right away
+  logger = Log4r::Logger.new("vagrant::bin::vagrant")
+  logger.info("`vagrant` invoked: #{ARGV.inspect}")
+
+  # 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") || ENV["VAGRANT_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?
+    # Cygwin always reports STDOUT is not a TTY, so we only disable
+    # colors if its not a TTY AND its not Cygwin.
+    opts[:ui_class] = Vagrant::UI::Basic
+  end
+
+  # Also allow users to force colors.
+  if argv.include?("--color") || ENV["VAGRANT_FORCE_COLOR"]
+    argv.delete("--color")
+    opts[:ui_class] = Vagrant::UI::Colored
+  end
+
+  # Highest precedence is if we have enabled machine-readable output
+  if argv.include?("--machine-readable")
+    argv.delete("--machine-readable")
+    opts[:ui_class] = Vagrant::UI::MachineReadable
+  end
+
+  # Setting to enable/disable showing progress bars
+  if argv.include?("--no-tty")
+    argv.delete("--no-tty")
+    opts[:ui_class] = Vagrant::UI::NonInteractive
+  end
+
+  # Default to colored output
+  opts[:ui_class] ||= Vagrant::UI::Colored
+
+  # Recombine the arguments
+  if !argv_extra.empty?
+    argv << "--"
+    argv += argv_extra
+  end
+
   # 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)
 
-  # Load the environment
-  logger.debug("Loading environment")
-  env.load!
+  # If we are running with the Windows Subsystem for Linux do
+  # some extra setup to allow access to Vagrant managed machines
+  # outside the subsystem
+  if Vagrant::Util::Platform.wsl?
+    recreate_env = Vagrant::Util::Platform.wsl_init(env, logger)
+    if recreate_env
+      logger.info("Re-creating Vagrant environment due to WSL modifications.")
+      env = Vagrant::Environment.new(opts)
+    end
+  end
+
+  # If not being run from the installer, check if expected tools
+  # are available.
+  if !Vagrant.in_installer?
+    missing_tools = Vagrant.detect_missing_tools
+
+    if !missing_tools.empty?
+      env.ui.warn(
+        I18n.t("vagrant.general.not_in_installer", tools: missing_tools.sort.join(", ")) + "\n",
+        prefix: false
+      )
+    end
+  end
+
+  # Acceptable experimental flag values include:
+  #
+  # Unset  - Disables experimental features
+  # 0      - Disables experimental features
+  # 1      - Enables all features
+  # String - Enables one or more features, separated by commas
+  if Vagrant::Util::Experimental.enabled?
+    experimental = Vagrant::Util::Experimental.features_requested
+    ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
+    logger.debug("Experimental flag is enabled")
+    if Vagrant::Util::Experimental.global_enabled?
+      ui.warn(I18n.t("vagrant.general.experimental.all"), bold: true, prefix: true, channel: :error)
+    else
+      ui.warn(I18n.t("vagrant.general.experimental.features", features: experimental.join(", ")), bold: true, prefix: true, channel: :error)
+    end
+  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 Exception => e
+  # It is possible for errors to happen in Vagrant's initialization. In
+  # this case, we don't have access to this class yet, so we check for it.
+  raise if !defined?(Vagrant) || !defined?(Vagrant::Errors)
+  raise if !e.is_a?(Vagrant::Errors::VagrantError)
 
-  # Execute the CLI interface, and exit with the proper error code
-  exit(env.cli(ARGV))
-rescue Vagrant::Errors::VagrantError => e
+  require 'log4r'
+  logger = Log4r::Logger.new("vagrant::bin::vagrant")
   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
+    opts = { prefix: false }
+    env.ui.error(e.message, **opts) if e.message
+    env.ui.machine("error-exit", e.class.to_s, e.message.to_s)
   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
+  exit 255 # An error occurred with no status code defined
 end

data/contrib/README.md

@@ -6,7 +6,12 @@ for each item will be kept below.
 
 ## List of Contrib Items
 
-* `emacs` - Contains a file showing how to associate `Vagrantfile` with
-  Ruby syntax highlighting.
+* `bash` - Contains a bash script for improving autocompletion with bash.
+* `emacs` - Contains a file for enabling Ruby syntax highlighting for `Vagrantfile`s in `emacs`.
+* `st` - Contains a `.sublime-settings` file for enabling Ruby syntax highlighting
+  for `Vagrantfile`s in Sublime Text.
+* `sudoers` - Contains the pieces of `/etc/sudoers` configuration to avoid password entry when
+  starting machines.
 * `vim` - Contains a `.vim` file for enabling Ruby syntax highlighting
-  for `Vagrantfile`s.
+  for `Vagrantfile`s in `vim`.
+* `zsh` - Contains a zsh script for improving autocompletion with zsh.