vagrantup 0.5.4 → 0.6.0

data/lib/vagrant/action/action_exception.rb

@@ -1,16 +0,0 @@
-module Vagrant
-  class Action
-    class ActionException < Exception
-      attr_reader :key
-      attr_reader :data
-
-      def initialize(key, data = {})
-        @key = key
-        @data = data
-
-        message = Vagrant::Util::Translator.t(key, data)
-        super(message)
-      end
-    end
-  end
-end

data/lib/vagrant/action/env/error_halt.rb

@@ -1,16 +0,0 @@
-module Vagrant
-  class Action
-    module Env
-      # A middleware which simply halts if the environment is erroneous.
-      class ErrorHalt
-        def initialize(app,env)
-          @app = app
-        end
-
-        def call(env)
-          @app.call(env) if !env.error?
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/action/exception_catcher.rb

@@ -1,14 +0,0 @@
-module Vagrant
-  class Action
-    # A helper to catch any ActionExceptions raised and to
-    # apply the error to the environment.
-    module ExceptionCatcher
-      def catch_action_exception(env)
-        yield env
-      rescue ActionException => e
-        env.error!(e.key, e.data)
-        false
-      end
-    end
-  end
-end

data/lib/vagrant/action/vm/persist.rb

@@ -1,22 +0,0 @@
-module Vagrant
-  class Action
-    module VM
-      class Persist
-        def initialize(app, env)
-          @app = app
-
-          # Error the environment if the dotfile is not valid
-          env.error!(:dotfile_error, :env => env.env) if File.exist?(env.env.dotfile_path) &&
-                                                         !File.file?(env.env.dotfile_path)
-        end
-
-        def call(env)
-          env.logger.info "Persisting the VM UUID (#{env["vm"].uuid})"
-          env.env.update_dotfile
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/active_list.rb

@@ -1,83 +0,0 @@
-module Vagrant
-  # This class represents the active list of vagrant virtual
-  # machines.
-  class ActiveList
-    FILENAME = "active.json"
-
-    @@list = nil
-
-    # The environment this active list belongs to
-    attr_accessor :env
-
-    # Creates the instance of the ActiveList, with the given environment
-    # if specified
-    def initialize(env=nil)
-      @env = env
-    end
-
-    # Parses and returns the list of UUIDs from the active VM
-    # JSON file. This will cache the result, which can be reloaded
-    # by setting the `reload` parameter to true.
-    #
-    # @return [Array<String>]
-    def list(reload=false)
-      return @list unless @list.nil? || reload
-
-      @list ||= {}
-      return @list unless File.file?(path)
-      File.open(path, "r") do |f|
-        begin
-          @list = JSON.parse(f.read)
-        rescue Exception
-          @list = {}
-        end
-
-        # This forces earlier versions of Vagrant to use the new hash
-        # format. Clearing out the old data isn't a big deal since it
-        # was never used.
-        @list = {} unless @list.is_a?(Hash)
-      end
-
-      @list
-    end
-
-    # Returns an array of UUIDs filtered so each is verified to exist.
-    def filter_list
-      list.each do |uuid, data|
-        list.delete(uuid) unless Vagrant::VM.find(uuid, env)
-      end
-
-      list
-    end
-
-    # Adds a virtual environment to the list of active virtual machines
-    def add(vm)
-      list[vm.uuid] = {
-        :path => env.root_path,
-        :created_at => Time.now.to_i
-      }
-
-      save
-    end
-
-    # Remove a virtual environment from the list of active virtual machines
-    def remove(vm)
-      vm = vm.uuid if vm.is_a?(Vagrant::VM)
-      list.delete(vm)
-      save
-    end
-
-    # Persists the list down to the JSON file.
-    def save
-      File.open(path, "w+") do |f|
-        f.write(filter_list.to_json)
-      end
-    end
-
-    # Returns the path to the JSON file which holds the UUIDs of the
-    # active virtual machines managed by Vagrant.
-    def path
-      File.join(env.home_path, FILENAME)
-    end
-  end
-end

data/lib/vagrant/command.rb

@@ -1,27 +0,0 @@
-module Vagrant
-  # This class handles commands from the command line program `vagrant`
-  # and redirects them to the proper sub-command, setting up the environment
-  # and executing.
-  class Command
-    attr_reader :env
-
-    class << self
-      # Executes a given subcommand within the current environment (from the
-      # current working directory).
-      def execute(*args)
-        env = Environment.load!
-        env.commands.subcommand(*args)
-      end
-    end
-
-    def initialize(env)
-      @env = env
-    end
-
-    # Execute a subcommand with the given name and args. This method properly
-    # finds the subcommand, instantiates it, and executes.
-    def subcommand(*args)
-      Commands::Base.dispatch(env, *args)
-    end
-  end
-end

data/lib/vagrant/commands/base.rb

@@ -1,181 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  class Commands
-    # This is the base command class which all sub-commands must
-    # inherit from. Subclasses of bases are expected to implement two
-    # methods: {#execute} and {#options_spec} (optional). The former
-    # defines the actual behavior of the command while the latter is a spec
-    # outlining the options that the command may take.
-    class Base
-      include Util
-
-      attr_reader :env
-
-      class << self
-        # Contains the list of registered subcommands. The registered commands are
-        # stored in a hash table and are therefore unordered.
-        #
-        # @return [Hash]
-        def subcommands
-          @subcommands ||= {}
-        end
-
-        # Registers a command with `vagrant`. This method allows 3rd parties to
-        # dynamically add new commands to the `vagrant` command, allowing plugins
-        # to act as 1st class citizens within vagrant.
-        #
-        # @param [String] key The subcommand which will invoke the registered command.
-        # @param [Class] klass. The subcommand class (a subclass of {Base})
-        def subcommand(key, klass)
-          subcommands[key] = klass
-        end
-
-        # Dispatches a subcommand to the proper registered command. Otherwise, it
-        # prints a help message.
-        def dispatch(env, *args)
-          klass = subcommands[args[0]] unless args.empty?
-          if klass.nil?
-            # Run _this_ command!
-            command = self.new(env)
-            command.execute(args)
-            return
-          end
-
-          # Shift off the front arg, since we just consumed it in finding the
-          # subcommand.
-          args.shift
-
-          # Dispatch to the next class
-          klass.dispatch(env, *args)
-        end
-
-        # Sets or reads the description, depending on if the value is set in the
-        # parameter.
-        def description(value=nil)
-          @description ||= ''
-
-          return @description if value.nil?
-          @description = value
-        end
-      end
-
-      def initialize(env)
-        @env = env
-      end
-
-      # This method should be overriden by subclasses. This is the method
-      # which is called by {Vagrant::Command} when a command is being
-      # executed. The `args` parameter is an array of parameters to the
-      # command (similar to ARGV)
-      def execute(args)
-        parse_options(args)
-
-        if options[:version]
-          puts_version
-        else
-          # Just print out the help, since this top-level command does nothing
-          # on its own
-          show_help
-        end
-      end
-
-      # This method is called by the base class to get the `optparse` configuration
-      # for the command.
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant SUBCOMMAND"
-
-        opts.on("--version", "Output running Vagrant version.") do |v|
-          options[:version] = v
-        end
-      end
-
-      #-------------------------------------------------------------------
-      # Methods below are not meant to be overriden/implemented by subclasses
-      #-------------------------------------------------------------------
-
-      # Parses the options for a given command and if a name was
-      # given, it calls the single method, otherwise it calls the all
-      # method. This helper is an abstraction which allows commands to
-      # easily be used in both regular and multi-VM environments.
-      def all_or_single(args, method_prefix)
-        args = parse_options(args)
-
-        single_method = "#{method_prefix}_single".to_sym
-        if args[0]
-          send(single_method, args[0])
-        else
-          env.vms.keys.each do |name|
-            send(single_method, name)
-          end
-        end
-      end
-
-      # Shows the version
-      def puts_version
-        puts VERSION
-      end
-
-      # Returns the `OptionParser` instance to be used with this subcommand,
-      # based on the specs defined in {#options_spec}.
-      def option_parser(reload=false)
-        @option_parser = nil if reload
-        @option_parser ||= OptionParser.new do |opts|
-          # The --help flag is available on all children commands, and will
-          # immediately show help.
-          opts.on("--help", "Show help for the current subcommand.") do
-            show_help
-          end
-
-          options_spec(opts)
-        end
-      end
-
-      # The options for the given command. This will just be an empty hash
-      # until {#parse_options} is called.
-      def options
-        @options ||= {}
-      end
-
-      # Parse options out of the command-line. This method uses `optparse`
-      # to parse command line options.
-      def parse_options(args)
-        option_parser.parse!(args)
-      rescue OptionParser::InvalidOption
-        show_help
-      end
-
-      # Gets the description of the command. This is similar grabbed from the
-      # class level.
-      def description
-        self.class.description
-      end
-
-      # Prints the help for the given command. Prior to calling this method,
-      # {#parse_options} must be called or a nilerror will be raised. This
-      # is by design.
-      def show_help
-        if !description.empty?
-          puts "Description: #{description}"
-        end
-
-        puts option_parser.help
-
-        my_klass = self.class
-        if !my_klass.subcommands.empty?
-          puts "\nSupported subcommands:"
-          my_klass.subcommands.keys.sort.each do |key|
-            klass = my_klass.subcommands[key]
-            next if klass.description.empty?
-
-            puts "#{' ' * 8}#{key.ljust(20)}#{klass.description}"
-          end
-
-          puts "\nFor help on a specific subcommand, run `vagrant SUBCOMMAND --help`"
-        end
-
-        exit
-      end
-    end
-  end
-end

data/lib/vagrant/commands/box.rb

@@ -1,16 +0,0 @@
-module Vagrant
-  class Commands
-    # Manages the `vagrant box` command, allowing the user to add
-    # and remove boxes. This single command, given an array, determines
-    # which action to take and calls the respective action method
-    # (see {box_add} and {box_remove})
-    class BoxCommand < Base
-      Base.subcommand "box", self
-      description "Box commands"
-
-      def options_spec(opts)
-        opts.banner = "Usage: vagrant box SUBCOMMAND"
-      end
-    end
-  end
-end

data/lib/vagrant/commands/box/add.rb

@@ -1,30 +0,0 @@
-module Vagrant
-  class Commands
-    # Adds a box to the local filesystem, given a URI.
-    module Box
-      class Add < BoxCommand
-        BoxCommand.subcommand "add", self
-        description "Add a box"
-
-        def execute(args)
-          if args.length != 2
-            show_help
-            return
-          end
-
-          box = Vagrant::Box.find(env, args[0])
-          if !box.nil?
-            error_and_exit(:box_already_exists)
-            return # for tests
-          end
-
-          Vagrant::Box.add(env, args[0], args[1])
-        end
-
-        def options_spec(opts)
-          opts.banner = "Usage: vagrant box add NAME URI"
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/commands/box/list.rb

@@ -1,30 +0,0 @@
-module Vagrant
-  class Commands
-    # Lists all added boxes
-    module Box
-      class List < BoxCommand
-        BoxCommand.subcommand "list", self
-        description "List all installed boxes"
-
-        def execute(args=[])
-          boxes = Vagrant::Box.all(env).sort
-
-          wrap_output do
-            if !boxes.empty?
-              puts "Installed Vagrant Boxes:\n\n"
-              boxes.each do |box|
-                puts box
-              end
-            else
-              puts "No Vagrant Boxes Added!"
-            end
-          end
-        end
-
-        def options_spec(opts)
-          opts.banner = "Usage: vagrant box list"
-        end
-      end
-    end
-  end
-end