vagrant-shell 0.2.9 → 0.2.11

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/loader.rb

@@ -1,222 +0,0 @@
-require "pathname"
-
-require "log4r"
-
-module Vagrant
-  module Config
-    # This class is responsible for loading Vagrant configuration,
-    # usually in the form of Vagrantfiles.
-    #
-    # Loading works by specifying the sources for the configuration
-    # as well as the order the sources should be loaded. Configuration
-    # set later always overrides those set earlier; this is how
-    # configuration "scoping" is implemented.
-    class Loader
-      # Initializes a configuration loader.
-      #
-      # @param [Registry] versions A registry of the available versions and
-      #   their associated loaders.
-      # @param [Array] version_order An array of the order of the versions
-      #   in the registry. This is used to determine if upgrades are
-      #   necessary. Additionally, the last version in this order is always
-      #   considered the "current" version.
-      def initialize(versions, version_order)
-        @logger        = Log4r::Logger.new("vagrant::config::loader")
-        @config_cache  = {}
-        @proc_cache    = {}
-        @sources       = {}
-        @versions      = versions
-        @version_order = version_order
-      end
-
-      # Set the configuration data for the given name.
-      #
-      # The `name` should be a symbol and must uniquely identify the data
-      # being given.
-      #
-      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
-      # `data` can also be an array of such values.
-      #
-      # At this point, no configuration is actually loaded. Note that calling
-      # `set` multiple times with the same name will override any previously
-      # set values. In this way, the last set data for a given name wins.
-      def set(name, sources)
-        @logger.info("Set #{name.inspect} = #{sources.inspect}")
-
-        # Sources should be an array
-        sources = [sources] if !sources.kind_of?(Array)
-
-        # Gather the procs for every source, since that is what we care about.
-        procs = []
-        sources.each do |source|
-          if !@proc_cache.has_key?(source)
-            # Load the procs for this source and cache them. This caching
-            # avoids the issue where a file may have side effects when loading
-            # and loading it multiple times causes unexpected behavior.
-            @logger.debug("Populating proc cache for #{source.inspect}")
-            @proc_cache[source] = procs_for_source(source)
-          end
-
-          # Add on to the array of procs we're going to use
-          procs.concat(@proc_cache[source])
-        end
-
-        # Set this source by name.
-        @sources[name] = procs
-      end
-
-      # This loads the configuration sources in the given order and returns
-      # an actual configuration object that is ready to be used.
-      #
-      # @param [Array<Symbol>] order The order of configuration to load.
-      # @return [Object] The configuration object. This is different for
-      #   each configuration version.
-      def load(order)
-        @logger.info("Loading configuration in order: #{order.inspect}")
-
-        unknown_sources = @sources.keys - order
-        if !unknown_sources.empty?
-          # TODO: Raise exception here perhaps.
-          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
-        end
-
-        # Get the current version config class to use
-        current_version      = @version_order.last
-        current_config_klass = @versions.get(current_version)
-
-        # This will hold our result
-        result = current_config_klass.init
-
-        # Keep track of the warnings and errors that may come from
-        # upgrading the Vagrantfiles
-        warnings = []
-        errors   = []
-
-        order.each do |key|
-          next if !@sources.has_key?(key)
-
-          @sources[key].each do |version, proc|
-            if !@config_cache.has_key?(proc)
-              @logger.debug("Loading from: #{key} (evaluating)")
-
-              # Get the proper version loader for this version and load
-              version_loader = @versions.get(version)
-              version_config = version_loader.load(proc)
-
-              # Store the errors/warnings associated with loading this
-              # configuration. We'll store these for later.
-              version_warnings = []
-              version_errors   = []
-
-              # If this version is not the current version, then we need
-              # to upgrade to the latest version.
-              if version != current_version
-                @logger.debug("Upgrading config from version #{version} to #{current_version}")
-                version_index = @version_order.index(version)
-                current_index = @version_order.index(current_version)
-
-                (version_index + 1).upto(current_index) do |index|
-                  next_version = @version_order[index]
-                  @logger.debug("Upgrading config to version #{next_version}")
-
-                  # Get the loader of this version and ask it to upgrade
-                  loader = @versions.get(next_version)
-                  upgrade_result = loader.upgrade(version_config)
-
-                  this_warnings = upgrade_result[1]
-                  this_errors   = upgrade_result[2]
-                  @logger.debug("Upgraded to version #{next_version} with " +
-                                "#{this_warnings.length} warnings and " +
-                                "#{this_errors.length} errors")
-
-                  # Append loading this to the version warnings and errors
-                  version_warnings += this_warnings
-                  version_errors   += this_errors
-
-                  # Store the new upgraded version
-                  version_config = upgrade_result[0]
-                end
-              end
-
-              # Cache the loaded configuration along with any warnings
-              # or errors so that they can be retrieved later.
-              @config_cache[proc] = [version_config, version_warnings, version_errors]
-            else
-              @logger.debug("Loading from: #{key} (cache)")
-            end
-
-            # Merge the configurations
-            cache_data = @config_cache[proc]
-            result = current_config_klass.merge(result, cache_data[0])
-
-            # Append the total warnings/errors
-            warnings += cache_data[1]
-            errors   += cache_data[2]
-          end
-        end
-
-        @logger.debug("Configuration loaded successfully, finalizing and returning")
-        [current_config_klass.finalize(result), warnings, errors]
-      end
-
-      protected
-
-      # This returns an array of `Proc` objects for the given source.
-      # The `Proc` objects returned will expect a single argument for
-      # the configuration object and are expected to mutate this
-      # configuration object.
-      def procs_for_source(source)
-        # Convert all pathnames to strings so we just have their path
-        source = source.to_s if source.is_a?(Pathname)
-
-        if source.is_a?(Array)
-          # An array must be formatted as [version, proc], so verify
-          # that and then return it
-          raise ArgumentError, "String source must have format [version, proc]" if source.length != 2
-
-          # Return it as an array since we're expected to return an array
-          # of [version, proc] pairs, but an array source only has one.
-          return [source]
-        elsif source.is_a?(String)
-          # Strings are considered paths, so load them
-          return procs_for_path(source)
-        else
-          raise ArgumentError, "Unknown configuration source: #{source.inspect}"
-        end
-      end
-
-      # This returns an array of `Proc` objects for the given path source.
-      #
-      # @param [String] path Path to the file which contains the proper
-      #   `Vagrant.configure` calls.
-      # @return [Array<Proc>]
-      def procs_for_path(path)
-        @logger.debug("Load procs for pathname: #{path}")
-
-        return Config.capture_configures do
-          begin
-            Kernel.load path
-          rescue SyntaxError => e
-            # Report syntax errors in a nice way.
-            raise Errors::VagrantfileSyntaxError, :file => e.message
-          rescue SystemExit
-            # Continue raising that exception...
-            raise
-          rescue Vagrant::Errors::VagrantError
-            # Continue raising known Vagrant errors since they already
-            # contain well worded error messages and context.
-            raise
-          rescue Exception => e
-            @logger.error("Vagrantfile load error: #{e.message}")
-            @logger.error(e.backtrace.join("\n"))
-
-            # Report the generic exception
-            raise Errors::VagrantfileLoadError,
-              :path => path,
-              :message => e.message
-          end
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v1/dummy_config.rb

@@ -1,13 +0,0 @@
-module Vagrant
-  module Config
-    module V1
-      # This is a configuration object that can have anything done
-      # to it. Anything, and it just appears to keep working.
-      class DummyConfig
-        def method_missing(name, *args, &block)
-          DummyConfig.new
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v1/loader.rb

@@ -1,105 +0,0 @@
-require "vagrant/config/v1/root"
-
-module Vagrant
-  module Config
-    module V1
-      # This is the loader that handles configuration loading for V1
-      # configurations.
-      class Loader < VersionBase
-        # Returns a bare empty configuration object.
-        #
-        # @return [V1::Root]
-        def self.init
-          new_root_object
-        end
-
-        # Finalizes the configuration by making sure there is at least
-        # one VM defined in it.
-        def self.finalize(config)
-          # Call the `#finalize` method on each of the configuration keys.
-          # They're expected to modify themselves in our case.
-          config.finalize!
-
-          # Return the object
-          config
-        end
-
-        # Loads the configuration for the given proc and returns a configuration
-        # object.
-        #
-        # @param [Proc] config_proc
-        # @return [Object]
-        def self.load(config_proc)
-          # Create a root configuration object
-          root = new_root_object
-
-          # Call the proc with the root
-          config_proc.call(root)
-
-          # Return the root object, which doubles as the configuration object
-          # we actually use for accessing as well.
-          root
-        end
-
-        # Merges two configuration objects.
-        #
-        # @param [V1::Root] old The older root config.
-        # @param [V1::Root] new The newer root config.
-        # @return [V1::Root]
-        def self.merge(old, new)
-          # Grab the internal states, we use these heavily throughout the process
-          old_state = old.__internal_state
-          new_state = new.__internal_state
-
-          # The config map for the new object is the old one merged with the
-          # new one.
-          config_map = old_state["config_map"].merge(new_state["config_map"])
-
-          # Merge the keys.
-          old_keys = old_state["keys"]
-          new_keys = new_state["keys"]
-          keys     = {}
-          old_keys.each do |key, old_value|
-            if new_keys.has_key?(key)
-              # We need to do a merge, which we expect to be available
-              # on the config class itself.
-              keys[key] = old_value.merge(new_keys[key])
-            else
-              # We just take the old value, but dup it so that we can modify.
-              keys[key] = old_value.dup
-            end
-          end
-
-          new_keys.each do |key, new_value|
-            # Add in the keys that the new class has that we haven't merged.
-            if !keys.has_key?(key)
-              keys[key] = new_value.dup
-            end
-          end
-
-          # Return the final root object
-          V1::Root.new(config_map, keys)
-        end
-
-        protected
-
-        def self.new_root_object
-          # Get all the registered configuration objects and use them. If
-          # we're currently on version 1, then we load all the config objects,
-          # otherwise we load only the upgrade safe ones, since we're
-          # obviously being loaded for an upgrade.
-          config_map = nil
-          plugin_manager = Vagrant.plugin("1").manager
-          if Config::CURRENT_VERSION == "1"
-            config_map = plugin_manager.config
-          else
-            config_map = plugin_manager.config_upgrade_safe
-          end
-
-          # Create the configuration root object
-          V1::Root.new(config_map)
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v1/root.rb

@@ -1,60 +0,0 @@
-require "set"
-
-module Vagrant
-  module Config
-    module V1
-      # This is the root configuration class. An instance of this is what
-      # is passed into version 1 Vagrant configuration blocks.
-      class Root
-        # Initializes a root object that maps the given keys to specific
-        # configuration classes.
-        #
-        # @param [Hash] config_map Map of key to config class.
-        def initialize(config_map, keys=nil)
-          @keys              = keys || {}
-          @config_map        = config_map
-          @missing_key_calls = Set.new
-        end
-
-        # We use method_missing as a way to get the configuration that is
-        # used for Vagrant and load the proper configuration classes for
-        # each.
-        def method_missing(name, *args)
-          return @keys[name] if @keys.has_key?(name)
-
-          config_klass = @config_map[name.to_sym]
-          if config_klass
-            # Instantiate the class and return the instance
-            @keys[name] = config_klass.new
-            return @keys[name]
-          else
-            # Record access to a missing key as an error
-            @missing_key_calls.add(name.to_s)
-            return DummyConfig.new
-          end
-        end
-
-        # Called to finalize this object just prior to it being used by
-        # the Vagrant system. The "!" signifies that this is expected to
-        # mutate itself.
-        def finalize!
-          @keys.each do |_key, instance|
-            instance.finalize!
-          end
-        end
-
-        # Returns the internal state of the root object. This is used
-        # by outside classes when merging, and shouldn't be called directly.
-        # Note the strange method name is to attempt to avoid any name
-        # clashes with potential configuration keys.
-        def __internal_state
-          {
-            "config_map"        => @config_map,
-            "keys"              => @keys,
-            "missing_key_calls" => @missing_key_calls
-          }
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v1.rb

@@ -1,9 +0,0 @@
-module Vagrant
-  module Config
-    module V1
-      autoload :DummyConfig, "vagrant/config/v1/dummy_config"
-      autoload :Loader, "vagrant/config/v1/loader"
-      autoload :Root,   "vagrant/config/v1/root"
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v2/dummy_config.rb

@@ -1,13 +0,0 @@
-module Vagrant
-  module Config
-    module V2
-      # This is a configuration object that can have anything done
-      # to it. Anything, and it just appears to keep working.
-      class DummyConfig
-        def method_missing(name, *args, &block)
-          DummyConfig.new
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v2/loader.rb

@@ -1,141 +0,0 @@
-require "vagrant/config/v2/root"
-
-module Vagrant
-  module Config
-    module V2
-      # This is the loader that handles configuration loading for V2
-      # configurations.
-      class Loader < VersionBase
-        # Returns a bare empty configuration object.
-        #
-        # @return [V2::Root]
-        def self.init
-          new_root_object
-        end
-
-        # Finalizes the configuration by making sure there is at least
-        # one VM defined in it.
-        def self.finalize(config)
-          # Call the `#finalize` method on each of the configuration keys.
-          # They're expected to modify themselves in our case.
-          config.finalize!
-
-          # Return the object
-          config
-        end
-
-        # Loads the configuration for the given proc and returns a configuration
-        # object.
-        #
-        # @param [Proc] config_proc
-        # @return [Object]
-        def self.load(config_proc)
-          # Create a root configuration object
-          root = new_root_object
-
-          # Call the proc with the root
-          config_proc.call(root)
-
-          # Return the root object, which doubles as the configuration object
-          # we actually use for accessing as well.
-          root
-        end
-
-        # Merges two configuration objects.
-        #
-        # @param [V2::Root] old The older root config.
-        # @param [V2::Root] new The newer root config.
-        # @return [V2::Root]
-        def self.merge(old, new)
-          # Grab the internal states, we use these heavily throughout the process
-          old_state = old.__internal_state
-          new_state = new.__internal_state
-
-          # The config map for the new object is the old one merged with the
-          # new one.
-          config_map = old_state["config_map"].merge(new_state["config_map"])
-
-          # Merge the keys.
-          old_keys = old_state["keys"]
-          new_keys = new_state["keys"]
-          keys     = {}
-          old_keys.each do |key, old_value|
-            if new_keys.has_key?(key)
-              # We need to do a merge, which we expect to be available
-              # on the config class itself.
-              keys[key] = old_value.merge(new_keys[key])
-            else
-              # We just take the old value, but dup it so that we can modify.
-              keys[key] = old_value.dup
-            end
-          end
-
-          new_keys.each do |key, new_value|
-            # Add in the keys that the new class has that we haven't merged.
-            if !keys.has_key?(key)
-              keys[key] = new_value.dup
-            end
-          end
-
-          # Merge the missing keys
-          new_missing_key_calls =
-            old_state["missing_key_calls"] + new_state["missing_key_calls"]
-
-          # Return the final root object
-          V2::Root.new(config_map).tap do |result|
-            result.__set_internal_state({
-              "config_map"        => config_map,
-              "keys"              => keys,
-              "missing_key_calls" => new_missing_key_calls
-            })
-          end
-        end
-
-        # Upgrade a V1 configuration to a V2 configuration. We do this by
-        # creating a V2 configuration, and calling "upgrade" on each of the
-        # V1 configurations, expecting them to set the right settings on the
-        # new root.
-        #
-        # @param [V1::Root] old
-        # @return [Array] A 3-tuple result.
-        def self.upgrade(old)
-          # Get a new root
-          root = new_root_object
-
-          # Store the warnings/errors
-          warnings = []
-          errors   = []
-
-          # Go through the old keys and upgrade them if they can be
-          old.__internal_state["keys"].each do |_, old_value|
-            if old_value.respond_to?(:upgrade)
-              result = old_value.upgrade(root)
-
-              # Sanity check to guard against random return values
-              if result.is_a?(Array)
-                warnings += result[0]
-                errors   += result[1]
-              end
-            end
-          end
-
-          old.__internal_state["missing_key_calls"].to_a.sort.each do |key|
-            warnings << I18n.t("vagrant.config.loader.bad_v1_key", :key => key)
-          end
-
-          [root, warnings, errors]
-        end
-
-        protected
-
-        def self.new_root_object
-          # Get all the registered plugins for V2
-          config_map = Vagrant.plugin("2").manager.config
-
-          # Create the configuration root object
-          V2::Root.new(config_map)
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v2/root.rb

@@ -1,105 +0,0 @@
-require "set"
-
-require "vagrant/config/v2/util"
-
-module Vagrant
-  module Config
-    module V2
-      # This is the root configuration class. An instance of this is what
-      # is passed into version 1 Vagrant configuration blocks.
-      class Root
-        # Initializes a root object that maps the given keys to specific
-        # configuration classes.
-        #
-        # @param [Hash] config_map Map of key to config class.
-        def initialize(config_map, keys=nil)
-          @keys              = keys || {}
-          @config_map        = config_map
-          @missing_key_calls = Set.new
-        end
-
-        # We use method_missing as a way to get the configuration that is
-        # used for Vagrant and load the proper configuration classes for
-        # each.
-        def method_missing(name, *args)
-          return @keys[name] if @keys.has_key?(name)
-
-          config_klass = @config_map[name.to_sym]
-          if config_klass
-            # Instantiate the class and return the instance
-            @keys[name] = config_klass.new
-            return @keys[name]
-          else
-            # Record access to a missing key as an error
-            @missing_key_calls.add(name.to_s)
-            return DummyConfig.new
-          end
-        end
-
-        # Called to finalize this object just prior to it being used by
-        # the Vagrant system. The "!" signifies that this is expected to
-        # mutate itself.
-        def finalize!
-          @keys.each do |_key, instance|
-            instance.finalize!
-          end
-        end
-
-        # This validates the configuration and returns a hash of error
-        # messages by section. If there are no errors, an empty hash
-        # is returned.
-        #
-        # @param [Environment] env
-        # @return [Hash]
-        def validate(machine)
-          # Go through each of the configuration keys and validate
-          errors = {}
-          @keys.each do |_key, instance|
-            if instance.respond_to?(:validate)
-              # Validate this single item, and if we have errors then
-              # we merge them into our total errors list.
-              result = instance.validate(machine)
-              if result && !result.empty?
-                errors = Util.merge_errors(errors, result)
-              end
-            end
-          end
-
-          # Go through and delete empty keys
-          errors.keys.each do |key|
-            errors.delete(key) if errors[key].empty?
-          end
-
-          # If we have missing keys, record those as errors
-          if !@missing_key_calls.empty?
-            errors["Vagrant"] = @missing_key_calls.to_a.sort.map do |key|
-              I18n.t("vagrant.config.root.bad_key", :key => key)
-            end
-          end
-
-          errors
-        end
-
-        # Returns the internal state of the root object. This is used
-        # by outside classes when merging, and shouldn't be called directly.
-        # Note the strange method name is to attempt to avoid any name
-        # clashes with potential configuration keys.
-        def __internal_state
-          {
-            "config_map"        => @config_map,
-            "keys"              => @keys,
-            "missing_key_calls" => @missing_key_calls
-          }
-        end
-
-        # This sets the internal state. This is used by the core to do some
-        # merging logic and shouldn't be used by the general public.
-        def __set_internal_state(state)
-          @config_map        = state["config_map"] if state.has_key?("config_map")
-          @keys              = state["keys"] if state.has_key?("keys")
-          @missing_key_calls = state["missing_key_calls"] if state.has_key?("missing_key_calls")
-        end
-      end
-    end
-  end
-end

data/demo/templates/vendor/bundle/ruby/1.9.1/gems/tnargav-1.2.2/lib/vagrant/config/v2/util.rb

@@ -1,21 +0,0 @@
-module Vagrant
-  module Config
-    module V2
-      class Util
-        # This merges two error hashes from validate methods.
-        #
-        # @param [Hash] first
-        # @param [Hash] second
-        # @return [Hash] Merged result
-        def self.merge_errors(first, second)
-          first.dup.tap do |result|
-            second.each do |key, value|
-              result[key] ||= []
-              result[key] += value
-            end
-          end
-        end
-      end
-    end
-  end
-end