vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/command/box.rb

@@ -1,58 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Box < Base
-      def initialize(argv, env)
-        super
-
-        @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-        @subcommands = Registry.new
-        @subcommands.register(:add)       { Vagrant::Command::BoxAdd }
-        @subcommands.register(:remove)    { Vagrant::Command::BoxRemove }
-        @subcommands.register(:repackage) { Vagrant::Command::BoxRepackage }
-        @subcommands.register(:list)      { Vagrant::Command::BoxList }
-      end
-
-      def execute
-        if @main_args.include?("-h") || @main_args.include?("--help")
-          # Print the help for all the box commands.
-          return help
-        end
-
-        # If we reached this far then we must have a subcommand. If not,
-        # then we also just print the help and exit.
-        command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
-        return help if !command_class || !@sub_command
-        @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
-
-        # Initialize and execute the command class
-        command_class.new(@sub_args, @env).execute
-      end
-
-      # Prints the help out for this command
-      def help
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box <command> [<args>]"
-          opts.separator ""
-          opts.separator "Available subcommands:"
-
-          # Add the available subcommands as separators in order to print them
-          # out as well.
-          keys = []
-          @subcommands.each { |key, value| keys << key.to_s }
-
-          keys.sort.each do |key|
-            opts.separator "     #{key}"
-          end
-
-          opts.separator ""
-          opts.separator "For help on any individual command run `vagrant box COMMAND -h`"
-        end
-
-        @env.ui.info(opts.help, :prefix => false)
-      end
-    end
-  end
-end

data/lib/vagrant/command/box_add.rb

@@ -1,37 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxAdd < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box add <name> <url>"
-          opts.separator ""
-
-          opts.on("-f", "--force", "Overwrite an existing box if it exists.") do |f|
-            options[:force] = f
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
-
-        # If we're force adding, then be sure to destroy any existing box if it
-        # exists.
-        if options[:force]
-          existing = @env.boxes.find(argv[0])
-          existing.destroy if existing
-        end
-
-        @env.boxes.add(argv[0], argv[1])
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/lib/vagrant/command/box_list.rb

@@ -1,28 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxList < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box list"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        boxes = @env.boxes.sort
-        if boxes.empty?
-          return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false)
-        end
-        boxes.each { |b| @env.ui.info(b.name, :prefix => false) }
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/box_remove.rb

@@ -1,27 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxRemove < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box remove <name>"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
-
-        b = @env.boxes.find(argv[0])
-        raise Errors::BoxNotFound, :name => argv[0] if !b
-        b.destroy
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/box_repackage.rb

@@ -1,27 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class BoxRepackage < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant box repackage <name>"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
-
-        b = @env.boxes.find(argv[0])
-        raise Errors::BoxNotFound, :name => argv[0] if !b
-        b.repackage
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/destroy.rb

@@ -1,64 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Destroy < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant destroy [vm-name]"
-          opts.separator ""
-
-          opts.on("-f", "--force", "Destroy without confirmation.") do |f|
-            options[:force] = f
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("'Destroy' each target VM...")
-        with_target_vms(argv, :reverse => true) do |vm|
-          if vm.created?
-            # Boolean whether we should actually go through with the destroy
-            # or not. This is true only if the "--force" flag is set or if the
-            # user confirms it.
-            do_destroy = false
-
-            if options[:force]
-              do_destroy = true
-            else
-              choice = nil
-              begin
-                choice = @env.ui.ask(I18n.t("vagrant.commands.destroy.confirmation",
-                                            :name => vm.name))
-              rescue Errors::UIExpectsTTY
-                # We raise a more specific error but one which basically
-                # means the same thing.
-                raise Errors::DestroyRequiresForce
-              end
-              do_destroy = choice.upcase == "Y"
-            end
-
-            if do_destroy
-              @logger.info("Destroying: #{vm.name}")
-              vm.destroy
-            else
-              @logger.info("Not destroying #{vm.name} since confirmation was declined.")
-              @env.ui.success(I18n.t("vagrant.commands.destroy.will_not_destroy",
-                                     :name => vm.name), :prefix => false)
-            end
-          else
-            @logger.info("Not destroying #{vm.name}, since it isn't created.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/gem.rb

@@ -1,39 +0,0 @@
-require "rubygems"
-require "rubygems/gem_runner"
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Command
-    class Gem < Base
-      include Util::SafePuts
-
-      def execute
-        # Bundler sets up its own custom gem load paths such that our
-        # own gems are never loaded. Therefore, give an error if a user
-        # tries to install gems while within a Bundler-managed environment.
-        if defined?(Bundler)
-          require 'bundler/shared_helpers'
-          if Bundler::SharedHelpers.in_bundle?
-            raise Errors::GemCommandInBundler
-          end
-        end
-
-        # If the user needs some help, we add our own little message at the
-        # top so that they're aware of what `vagrant gem` is doing, really.
-        if @argv.empty? || @argv.include?("-h") || @argv.include?("--help")
-          @env.ui.info(I18n.t("vagrant.commands.gem.help_preamble"),
-                       :prefix => false)
-          safe_puts
-        end
-
-        # We just proxy the arguments onto a real RubyGems command
-        # but change `GEM_HOME` so that the gems are installed into
-        # our own private gem folder.
-        ENV["GEM_HOME"] = @env.gems_path.to_s
-        ::Gem.clear_paths
-        ::Gem::GemRunner.new.run(@argv.dup)
-      end
-    end
-  end
-end

data/lib/vagrant/command/halt.rb

@@ -1,39 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Halt < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant halt [vm-name] [--force] [-h]"
-
-          opts.separator ""
-
-          opts.on("-f", "--force", "Force shut down (equivalent of pulling power)") do |f|
-            options[:force] = f
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("Halt command: #{argv.inspect} #{options.inspect}")
-        with_target_vms(argv) do |vm|
-          if vm.created?
-            @logger.info("Halting #{vm.name}")
-            vm.halt(:force => options[:force])
-          else
-            @logger.info("Not halting #{vm.name}, since not created.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/package.rb

@@ -1,75 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Package < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant package [vm-name] [--base name] [--output name.box]"
-          opts.separator "                       [--include one,two,three] [--vagrantfile file]"
-
-          opts.separator ""
-
-          opts.on("--base NAME", "Name of a VM in virtualbox to package as a base box") do |b|
-            options[:base] = b
-          end
-
-          opts.on("--output NAME", "Name of the file to output") do |o|
-            options[:output] = o
-          end
-
-          opts.on("--include x,y,z", Array, "Additional files to package with the box.") do |i|
-            options[:include] = i
-          end
-
-          opts.on("--vagrantfile file", "Vagrantfile to package with the box.") do |v|
-            options[:vagrantfile] = v
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("package options: #{options.inspect}")
-        if options[:base]
-          package_base(options)
-        else
-          package_target(argv[0], options)
-        end
-
-        # Success, exit status 0
-        0
-       end
-
-      protected
-
-      def package_base(options)
-        vm = VM.new(options[:base], @env, @env.config.global, :base => true)
-        raise Errors::BaseVMNotFound, :name => options[:base] if !vm.created?
-        @logger.debug("Packaging base VM: #{vm.name}")
-        package_vm(vm, options)
-      end
-
-      def package_target(name, options)
-        with_target_vms(name, :single_target => true) do |vm|
-          raise Errors::VMNotCreatedError if !vm.created?
-          @logger.debug("Packaging VM: #{vm.name}")
-          package_vm(vm, options)
-        end
-      end
-
-      def package_vm(vm, options)
-        opts = options.inject({}) do |acc, data|
-          k,v = data
-          acc["package.#{k}"] = v
-          acc
-        end
-
-        vm.package(opts)
-      end
-    end
-  end
-end

data/lib/vagrant/command/provision.rb

@@ -1,40 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Provision < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant provision [vm-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        # Go over each VM and provision!
-        @logger.debug("'provision' each target VM...")
-        with_target_vms(argv) do |vm|
-          
-          if vm.created?
-            if vm.state == :running
-              @logger.info("Provisioning: #{vm.name}")
-              vm.provision
-            else
-              @logger.info("#{vm.name} not running. Not provisioning.")
-              vm.ui.info I18n.t("vagrant.commands.common.vm_not_running")
-            end
-          else
-            @logger.info("#{vm.name} not created. Not provisioning.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end