vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/capability_host.rb

@@ -1,177 +0,0 @@
-module Vagrant
-  # This module enables a class to host capabilities. Prior to being able
-  # to use any capabilities, the `initialize_capabilities!` method must be
-  # called.
-  #
-  # Capabilities allow small pieces of functionality to be plugged in using
-  # the Vagrant plugin model. Capabilities even allow for a certain amount
-  # of inheritance, where only a subset of capabilities may be implemented but
-  # a parent implements the rest.
-  #
-  # Capabilities are used heavily in Vagrant for host/guest interactions. For
-  # example, "mount_nfs_folder" is a guest-OS specific operation, so capabilities
-  # defer these operations to the guest.
-  module CapabilityHost
-    # Initializes the capability system by detecting the proper capability
-    # host to execute on and building the chain of capabilities to execute.
-    #
-    # @param [Symbol] host The host to use for the capabilities, or nil if
-    #   we should auto-detect it.
-    # @param [Hash<Symbol, Array<Class, Symbol>>] hosts Potential capability
-    #   hosts. The key is the name of the host, value[0] is a class that
-    #   implements `#detect?` and value[1] is a parent host (if any).
-    # @param [Hash<Symbol, Hash<Symbol, Class>>] capabilities The capabilities
-    #   that are supported. The key is the host of the capability. Within that
-    #   is a hash where the key is the name of the capability and the value
-    #   is the class/module implementing it.
-    def initialize_capabilities!(host, hosts, capabilities, *args)
-      @cap_logger = Log4r::Logger.new(
-        "vagrant::capability_host::#{self.class.to_s.downcase}")
-
-      if host && !hosts[host]
-        raise Errors::CapabilityHostExplicitNotDetected, value: host.to_s
-      end
-
-      if !host
-        host = autodetect_capability_host(hosts, *args) if !host
-        raise Errors::CapabilityHostNotDetected if !host
-      end
-
-      if !hosts[host]
-        # This should never happen because the autodetect above uses the
-        # hosts hash to look up hosts. And if an explicit host is specified,
-        # we do another check higher up.
-        raise "Internal error. Host not found: #{host}"
-      end
-
-      name      = host
-      host_info = hosts[name]
-      host      = host_info[0].new
-      chain     = []
-      chain << [name, host]
-
-      # Build the proper chain of parents if there are any.
-      # This allows us to do "inheritance" of capabilities later
-      if host_info[1]
-        parent_name = host_info[1]
-        parent_info = hosts[parent_name]
-        while parent_info
-          chain << [parent_name, parent_info[0].new]
-          parent_name = parent_info[1]
-          parent_info = hosts[parent_name]
-        end
-      end
-
-      @cap_host_chain = chain
-      @cap_args       = args
-      @cap_caps       = capabilities
-      true
-    end
-
-    # Returns the chain of hosts that will be checked for capabilities.
-    #
-    # @return [Array<Array<Symbol, Class>>]
-    def capability_host_chain
-      @cap_host_chain
-    end
-
-    # Tests whether the given capability is possible.
-    #
-    # @param [Symbol] cap_name Capability name
-    # @return [Boolean]
-    def capability?(cap_name)
-      !capability_module(cap_name.to_sym).nil?
-    end
-
-    # Executes the capability with the given name, optionally passing more
-    # arguments onwards to the capability. If the capability returns a value,
-    # it will be returned.
-    #
-    # @param [Symbol] cap_name Name of the capability
-    def capability(cap_name, *args)
-      cap_mod = capability_module(cap_name.to_sym)
-      if !cap_mod
-        raise Errors::CapabilityNotFound,
-          cap:  cap_name.to_s,
-          host: @cap_host_chain[0][0].to_s
-      end
-
-      cap_method = nil
-      begin
-        cap_method = cap_mod.method(cap_name)
-      rescue NameError
-        raise Errors::CapabilityInvalid,
-          cap: cap_name.to_s,
-          host: @cap_host_chain[0][0].to_s
-      end
-
-      args = @cap_args + args
-      @cap_logger.info(
-        "Execute capability: #{cap_name} #{args.inspect} (#{@cap_host_chain[0][0]})")
-      cap_method.call(*args)
-    end
-
-    protected
-
-    def autodetect_capability_host(hosts, *args)
-      @cap_logger.info("Autodetecting host type for #{args.inspect}")
-
-      # Get the mapping of hosts with the most parents. We start searching
-      # with the hosts with the most parents first.
-      parent_count = {}
-      hosts.each do |name, parts|
-        parent_count[name] = 0
-
-        parent = parts[1]
-        while parent
-          parent_count[name] += 1
-          parent = hosts[parent]
-          parent = parent[1] if parent
-        end
-      end
-
-      # Now swap around the mapping so that it is a mapping of
-      # count to the actual list of host names
-      parent_count_to_hosts = {}
-      parent_count.each do |name, count|
-        parent_count_to_hosts[count] ||= []
-        parent_count_to_hosts[count] << name
-      end
-
-      sorted_counts = parent_count_to_hosts.keys.sort.reverse
-      sorted_counts.each do |count|
-        parent_count_to_hosts[count].each do |name|
-          @cap_logger.debug("Trying: #{name}")
-          host_info = hosts[name]
-          host      = host_info[0].new
-
-          if host.detect?(*args)
-            @cap_logger.info("Detected: #{name}!")
-            return name
-          end
-        end
-      end
-
-      return nil
-    end
-
-    # Returns the registered module for a capability with the given name.
-    #
-    # @param [Symbol] cap_name
-    # @return [Module]
-    def capability_module(cap_name)
-      @cap_logger.debug("Searching for cap: #{cap_name}")
-      @cap_host_chain.each do |host_name, host|
-        @cap_logger.debug("Checking in: #{host_name}")
-        caps = @cap_caps[host_name]
-
-        if caps && caps.key?(cap_name)
-          @cap_logger.debug("Found cap: #{cap_name} in #{host_name}")
-          return caps[cap_name]
-        end
-      end
-
-      nil
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/cli.rb

@@ -1,108 +0,0 @@
-require 'log4r'
-require 'optparse'
-
-module Vagrant
-  # Manages the command line interface to Vagrant.
-  class CLI < Vagrant.plugin("2", :command)
-
-    def initialize(argv, env)
-      super
-
-      @logger = Log4r::Logger.new("vagrant::cli")
-      @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-      Util::CheckpointClient.instance.setup(env).check
-      @logger.info("CLI: #{@main_args.inspect} #{@sub_command.inspect} #{@sub_args.inspect}")
-    end
-
-    def execute
-      if @main_args.include?("-h") || @main_args.include?("--help")
-        # Help is next in short-circuiting everything. Print
-        # the help and exit.
-        help
-        return 0
-      end
-
-      # If we reached this far then we must have a subcommand. If not,
-      # then we also just print the help and exit.
-      command_plugin = nil
-      if @sub_command
-        command_plugin = Vagrant.plugin("2").manager.commands[@sub_command.to_sym]
-
-        if !command_plugin
-          alias_command = Alias.new(@env).commands[@sub_command.to_sym]
-
-          if alias_command
-            return alias_command.call(@sub_args)
-          end
-        end
-      end
-
-      if !command_plugin || !@sub_command
-        help
-        return 1
-      end
-
-      command_class = command_plugin[0].call
-      @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
-
-      Util::CheckpointClient.instance.display
-
-      # Initialize and execute the command class, returning the exit status.
-      result = 0
-      begin
-        result = command_class.new(@sub_args, @env).execute
-      rescue Interrupt
-        @env.ui.info(I18n.t("vagrant.cli_interrupt"))
-        result = 1
-      end
-
-      result = 0 if !result.is_a?(Integer)
-      return result
-    end
-
-    # This prints out the help for the CLI.
-    def help
-      # We use the optionparser for this. Its just easier. We don't use
-      # an optionparser above because I don't think the performance hits
-      # of creating a whole object are worth checking only a couple flags.
-      opts = OptionParser.new do |o|
-        o.banner = "Usage: vagrant [options] <command> [<args>]"
-        o.separator ""
-        o.on("-v", "--version", "Print the version and exit.")
-        o.on("-h", "--help", "Print this help.")
-        o.separator ""
-        o.separator "Common commands:"
-
-        # Add the available subcommands as separators in order to print them
-        # out as well.
-        commands = {}
-        longest = 0
-        Vagrant.plugin("2").manager.commands.each do |key, data|
-          # Skip non-primary commands. These only show up in extended
-          # help output.
-          next if !data[1][:primary]
-
-          key           = key.to_s
-          klass         = data[0].call
-          commands[key] = klass.synopsis
-          longest       = key.length if key.length > longest
-        end
-
-        commands.keys.sort.each do |key|
-          o.separator "     #{key.ljust(longest+2)} #{commands[key]}"
-          @env.ui.machine("cli-command", key.dup)
-        end
-
-        o.separator ""
-        o.separator "For help on any individual command run `vagrant COMMAND -h`"
-        o.separator ""
-        o.separator "Additional subcommands are available, but are either more advanced"
-        o.separator "or not commonly used. To see all subcommands, run the command"
-        o.separator "`vagrant list-commands`."
-      end
-
-      @env.ui.info(opts.help, prefix: false)
-    end
-  end
-end

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

@@ -1,275 +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)
-        # Sources should be an array
-        sources = [sources] if !sources.kind_of?(Array)
-
-        reliably_inspected_sources = sources.reduce({}) { |accum, source|
-          begin
-            accum[source] = source.inspect
-          rescue Encoding::CompatibilityError
-            accum[source] = "<!Vagrant failed to call #inspect source with object id #{source.object_id} and class #{source.class} due to a string encoding error>"
-          end
-
-          accum
-        }
-
-        @logger.info("Set #{name.inspect} = #{reliably_inspected_sources.values}")
-
-        # Gather the procs for every source, since that is what we care about.
-        procs = []
-        sources.each do |source|
-          if !@proc_cache.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 #{reliably_inspected_sources[source]}")
-            @proc_cache[source] = procs_for_source(source, reliably_inspected_sources)
-          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?
-          @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   = []
-
-        if !@sources[:root].nil? && @sources[:root].eql?(@sources[:home])
-          # Vagrants home dir is set to the same dir as its project directory
-          # so we don't want to load and merge the same Vagrantfile config
-          # and execute its settings/procs twice
-          #
-          # Note: This protection won't work if there are two separate but
-          # identical Vagrantfiles in the home and project dir
-          @logger.info("Duplicate Vagrantfile config objects detected in :root and :home.")
-          @sources.delete(:home)
-          @logger.info("Removed :home config from being loaded")
-        end
-
-        order.each do |key|
-          next if !@sources.key?(key)
-
-          @sources[key].each do |version, proc|
-            if !@config_cache.key?(proc)
-              @logger.debug("Loading from: #{key} (evaluating)")
-
-              # Get the proper version loader for this version and load
-              version_loader = @versions.get(version)
-              begin
-                version_config = version_loader.load(proc)
-              rescue NameError => e
-                line = "(unknown)"
-                path = "(unknown)"
-                if e.backtrace && e.backtrace[0]
-                  backtrace_tokens = e.backtrace[0].split(":")
-                  path = backtrace_tokens[0]
-                  backtrace_tokens.each do |part|
-                    if part =~ /\d+/
-                      line = part.to_i
-                      break
-                    end
-                  end
-                end
-
-                raise Errors::VagrantfileNameError,
-                  path: path,
-                  line: line,
-                  message: e.message.sub(/' for .*$/, "'")
-              end
-
-              # 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, reliably_inspected_sources)
-        # 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: #{reliably_inspected_sources[source]}"
-        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"))
-
-            line = "(unknown)"
-            if e.backtrace && e.backtrace[0]
-              e.backtrace[0].split(":").each do |part|
-                if part =~ /\d+/
-                  line = part.to_i
-                  break
-                end
-              end
-            end
-
-            # Report the generic exception
-            raise Errors::VagrantfileLoadError,
-              path: path,
-              line: line,
-              exception_class: e.class,
-              message: e.message
-          end
-        end
-      end
-    end
-  end
-end

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