vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/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.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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/config/v2/loader.rb

@@ -1,151 +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
-
-          # Make sure we instantiate every key in the config so that we
-          # merge every key. This avoids issues with the same reference
-          # being part of the config.
-          old_state["config_map"].each do |k, _|
-            old.public_send(k)
-          end
-          new_state["config_map"].each do |k, _|
-            new.public_send(k)
-          end
-
-          # 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.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.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/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/config/v2/root.rb

@@ -1,114 +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 2 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
-          @logger            = Log4r::Logger.new("vagrant::config")
-        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.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
-            @logger.debug("missing key request name=#{name} loc=#{caller.first}")
-            # 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!
-          @config_map.each do |key, klass|
-            if !@keys.key?(key)
-              @keys[key] = klass.new
-            end
-          end
-
-          @keys.each do |_key, instance|
-            instance.finalize!
-            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.key?("config_map")
-          @keys              = state["keys"] if state.key?("keys")
-          @missing_key_calls = state["missing_key_calls"] if state.key?("missing_key_calls")
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/config/v2.rb

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

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/config/version_base.rb

@@ -1,80 +0,0 @@
-module Vagrant
-  module Config
-    # This is the base class for any configuration versions, and includes
-    # the stub methods that configuration versions must implement. Vagrant
-    # supports configuration versioning so that backwards compatibility can be
-    # maintained for past Vagrantfiles while newer configurations are added.
-    # Vagrant only introduces new configuration versions for major versions
-    # of Vagrant.
-    class VersionBase
-      # Returns an empty configuration object. This can be any kind of object,
-      # since it is treated as an opaque value on the other side, used only
-      # for things like calling into {merge}.
-      #
-      # @return [Object]
-      def self.init
-        raise NotImplementedError
-      end
-
-      # This is called just before configuration loading is complete of
-      # a potentially completely-merged value to perform final touch-ups
-      # to the configuration, if required.
-      #
-      # This is an optional method to implement. The default implementation
-      # will simply return the same object.
-      #
-      # This will ONLY be called if this is the version that is being
-      # used. In the case that an `upgrade` is called, this will never
-      # be called.
-      #
-      # @param [Object] obj Final configuration object.
-      # @param [Object] Finalized configuration object.
-      def self.finalize(obj)
-        obj
-      end
-
-      # Loads the configuration for the given proc and returns a configuration
-      # object. The return value is treated as an opaque object, so it can be
-      # anything you'd like. The return value is the object that is passed
-      # into methods like {merge}, so it should be something you expect.
-      #
-      # @param [Proc] proc The proc that is to be configured.
-      # @return [Object]
-      def self.load(proc)
-        raise NotImplementedError
-      end
-
-      # Merges two configuration objects, returning the merged object.
-      # The values of `old` and `new` are the opaque objects returned by
-      # {load} or {init}.
-      #
-      # Once again, the return object is treated as an opaque value by
-      # the Vagrant configuration loader, so it can be anything you'd like.
-      #
-      # @param [Object] old Old configuration object.
-      # @param [Object] new New configuration object.
-      # @return [Object] The merged configuration object.
-      def self.merge(old, new)
-        raise NotImplementedError
-      end
-
-      # This is called if a previous version of configuration needs to be
-      # upgraded to this version. Each version of configuration should know
-      # how to upgrade the version immediately prior to it. This should be
-      # a best effort upgrade that makes many assumptions. The goal is for
-      # this to work in almost every case, but perhaps with some warnings.
-      # The return value for this is a 3-tuple: `[object, warnings, errors]`,
-      # where `object` is the upgraded configuration object, `warnings` is
-      # an array of warning messages, and `errors` is an array of error
-      # messages.
-      #
-      # @param [Object] old The version of the configuration object just
-      #   prior to this one.
-      # @return [Array] The 3-tuple result. Please see the above documentation
-      #   for more information on the exact structure of this object.
-      def self.upgrade(old)
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/config.rb

@@ -1,61 +0,0 @@
-require "vagrant/registry"
-
-module Vagrant
-  module Config
-    autoload :Loader,        'vagrant/config/loader'
-    autoload :VersionBase,   'vagrant/config/version_base'
-
-    autoload :V1,            'vagrant/config/v1'
-    autoload :V2,            'vagrant/config/v2'
-
-    # This is a mutex used to guarantee that only one thread can load
-    # procs at any given time.
-    CONFIGURE_MUTEX = Mutex.new
-
-    # This is the registry which keeps track of what configuration
-    # versions are available, mapped by the version string used in
-    # `Vagrant.configure` calls.
-    VERSIONS = Registry.new
-    VERSIONS.register("1") { V1::Loader }
-    VERSIONS.register("2") { V2::Loader }
-
-    # This is the order of versions. This is used by the loader to figure out
-    # how to "upgrade" versions up to the desired (current) version. The
-    # current version is always considered to be the last version in this
-    # list.
-    VERSIONS_ORDER = ["1", "2"]
-    CURRENT_VERSION = VERSIONS_ORDER.last
-
-    # This is the method which is called by all Vagrantfiles to configure Vagrant.
-    # This method expects a block which accepts a single argument representing
-    # an instance of the {Config::Top} class.
-    #
-    # Note that the block is not run immediately. Instead, it's proc is stored
-    # away for execution later.
-    def self.run(version="1", &block)
-      # Store it for later
-      @last_procs ||= []
-      @last_procs << [version.to_s, block]
-    end
-
-    # This is a method which will yield to a block and will capture all
-    # ``Vagrant.configure`` calls, returning an array of `Proc`s.
-    #
-    # Wrapping this around anytime you call code which loads configurations
-    # will force a mutex so that procs never get mixed up. This keeps
-    # the configuration loading part of Vagrant thread-safe.
-    def self.capture_configures
-      CONFIGURE_MUTEX.synchronize do
-        # Reset the last procs so that we start fresh
-        @last_procs = []
-
-        # Yield to allow the caller to do whatever loading needed
-        yield
-
-        # Return the last procs we've seen while still in the mutex,
-        # knowing we're safe.
-        return @last_procs
-      end
-    end
-  end
-end