vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,88 +0,0 @@
-require 'ostruct'
-require "pathname"
-
-require 'erubis'
-
-module Vagrant
-  module Util
-    # This class is used to render the ERB templates in the
-    # `GEM_ROOT/templates` directory.
-    class TemplateRenderer < OpenStruct
-      class << self
-        # Render a given template and return the result. This method optionally
-        # takes a block which will be passed the renderer prior to rendering, which
-        # allows the caller to set any view variables within the renderer itself.
-        #
-        # @return [String] Rendered template
-        def render(*args)
-          render_with(:render, *args)
-        end
-
-        # Render a given string and return the result. This method optionally
-        # takes a block which will be passed the renderer prior to rendering, which
-        # allows the caller to set any view variables within the renderer itself.
-        #
-        # @param [String] template The template data string.
-        # @return [String] Rendered template
-        def render_string(*args)
-          render_with(:render_string, *args)
-        end
-
-        # Method used internally to DRY out the other renderers. This method
-        # creates and sets up the renderer before calling a specified method on it.
-        def render_with(method, template, data={})
-          renderer = new(template, data)
-          yield renderer if block_given?
-          renderer.send(method.to_sym)
-        end
-      end
-
-      def initialize(template, data = {})
-        super()
-
-        @template_root = data.delete(:template_root)
-        @template_root ||= Vagrant.source_root.join("templates")
-        @template_root = Pathname.new(@template_root)
-
-        data[:template] = template
-        data.each do |key, value|
-          send("#{key}=", value)
-        end
-      end
-
-      # Renders the template using the class instance as the binding. Because the
-      # renderer inherits from `OpenStruct`, additional view variables can be
-      # added like normal accessors.
-      #
-      # @return [String]
-      def render
-        old_template = template
-        result = nil
-        File.open(full_template_path, 'r') do |f|
-          self.template = f.read
-          result = render_string
-        end
-
-        result
-      ensure
-        self.template = old_template
-      end
-
-      # Renders a template, handling the template as a string, but otherwise
-      # acting the same way as {#render}.
-      #
-      # @return [String]
-      def render_string
-        Erubis::Eruby.new(template, trim: true).result(binding)
-      end
-
-      # Returns the full path to the template, taking into account the gem directory
-      # and adding the `.erb` extension to the end.
-      #
-      # @return [String]
-      def full_template_path
-        @template_root.join("#{template}.erb").to_s.squeeze("/")
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require "vagrant/util/platform"
-
-module Vagrant
-  module Util
-    class Which
-      # Cross-platform way of finding an executable in the PATH.
-      #
-      #   which('ruby') #=> /usr/bin/ruby
-      #
-      # This code is adapted from the following post by mislav:
-      #   http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
-      #
-      # @param [String] cmd The command to search for in the PATH.
-      # @param [Hash] opts Optional flags
-      #   @option [Boolean] :original_path Search within original path if available
-      # @return [String] The full path to the executable or `nil` if not found.
-      def self.which(cmd, **opts)
-        exts = nil
-
-        if !Platform.windows? || ENV['PATHEXT'].nil?
-          # If the PATHEXT variable is empty, we're on *nix and need to find
-          # the exact filename
-          exts = ['']
-        elsif File.extname(cmd).length != 0
-          # On Windows: if filename contains an extension, we must match that
-          # exact filename
-          exts = ['']
-        else
-          # On Windows: otherwise try to match all possible executable file
-          # extensions (.EXE .COM .BAT etc.)
-          exts = ENV['PATHEXT'].split(';')
-        end
-
-        if opts[:original_path]
-          search_path = ENV.fetch('VAGRANT_OLD_ENV_PATH', ENV['PATH'])
-        else
-          search_path = ENV['PATH']
-        end
-
-        SilenceWarnings.silence! do
-          search_path.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '').split(File::PATH_SEPARATOR).each do |path|
-            exts.each do |ext|
-              exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
-              return exe if File.executable? exe
-            end
-          end
-        end
-
-        return nil
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require "fiddle/import"
-
-module Vagrant
-  module Util
-    module WindowsPath
-      module API
-        extend Fiddle::Importer
-        dlload 'kernel32.dll'
-        extern("int GetLongPathNameA(char*, char*, int)", :stdcall)
-      end
-
-      # Converts a Windows shortname to a long name. This only works
-      # for ASCII paths currently and doesn't use the wide character
-      # support.
-      def self.longname(name)
-        # We loop over the API call in case we didn't allocate enough
-        # buffer space. In general it is usually enough.
-        bufferlen = 250
-        buffer    = nil
-        while true
-          buffer = ' ' * bufferlen
-          len    = API.GetLongPathNameA(name.to_s, buffer, buffer.size)
-          if bufferlen < len
-            # If the length returned is larger than our buffer length,
-            # it is the API telling us it needs more space. Allocate it
-            # and retry.
-            bufferlen = len
-            continue
-          end
-
-          break
-        end
-
-        return buffer.rstrip.chomp("\0")
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Vagrant
-  module Util
-    autoload :Busy,                      'vagrant/util/busy'
-    autoload :CheckpointClient,          'vagrant/util/checkpoint_client'
-    autoload :CommandDeprecation,        'vagrant/util/command_deprecation'
-    autoload :Counter,                   'vagrant/util/counter'
-    autoload :CredentialScrubber,        'vagrant/util/credential_scrubber'
-    autoload :DeepMerge,                 'vagrant/util/deep_merge'
-    autoload :Env,                       'vagrant/util/env'
-    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
-    autoload :GuestInspection,           'vagrant/util/guest_inspection'
-    autoload :LoggingFormatter,          'vagrant/util/logging_formatter'
-    autoload :Platform,                  'vagrant/util/platform'
-    autoload :Retryable,                 'vagrant/util/retryable'
-    autoload :SafeExec,                  'vagrant/util/safe_exec'
-    autoload :SilenceWarnings,           'vagrant/util/silence_warnings'
-    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
-    autoload :StringBlockEditor,         'vagrant/util/string_block_editor'
-    autoload :Subprocess,                'vagrant/util/subprocess'
-    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
-    autoload :Which,                     'vagrant/util/which'
-  end
-end

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

@@ -1,280 +0,0 @@
-require "vagrant/util/template_renderer"
-
-module Vagrant
-  # This class provides a way to load and access the contents
-  # of a Vagrantfile.
-  #
-  # This class doesn't actually load Vagrantfiles, parse them,
-  # merge them, etc. That is the job of {Config::Loader}. This
-  # class, on the other hand, has higher-level operations on
-  # a loaded Vagrantfile such as looking up the defined machines,
-  # loading the configuration of a specific machine/provider combo,
-  # etc.
-  class Vagrantfile
-    # This is the configuration loaded as-is given the loader and
-    # keys to #initialize.
-    attr_reader :config
-
-    # Initializes by loading a Vagrantfile.
-    #
-    # @param [Config::Loader] loader Configuration loader that should
-    #   already be configured with the proper Vagrantfile locations.
-    #   This usually comes from {Vagrant::Environment}
-    # @param [Array<Symbol>] keys The Vagrantfiles to load and the
-    #   order to load them in (keys within the loader).
-    def initialize(loader, keys)
-      @keys   = keys
-      @loader = loader
-      @config, _ = loader.load(keys)
-    end
-
-    # Returns a {Machine} for the given name and provider that
-    # is represented by this Vagrantfile.
-    #
-    # @param [Symbol] name Name of the machine.
-    # @param [Symbol] provider The provider the machine should
-    #   be backed by (required for provider overrides).
-    # @param [BoxCollection] boxes BoxCollection to look up the
-    #   box Vagrantfile.
-    # @param [Pathname] data_path Path where local machine data
-    #   can be stored.
-    # @param [Environment] env The environment running this machine
-    # @return [Machine]
-    def machine(name, provider, boxes, data_path, env)
-      # Load the configuration for the machine
-      results = machine_config(name, provider, boxes)
-      box             = results[:box]
-      config          = results[:config]
-      config_errors   = results[:config_errors]
-      config_warnings = results[:config_warnings]
-      provider_cls    = results[:provider_cls]
-      provider_options = results[:provider_options]
-
-      # If there were warnings or errors we want to output them
-      if !config_warnings.empty? || !config_errors.empty?
-        # The color of the output depends on whether we have warnings
-        # or errors...
-        level  = config_errors.empty? ? :warn : :error
-        output = Util::TemplateRenderer.render(
-          "config/messages",
-          warnings: config_warnings,
-          errors: config_errors).chomp
-        env.ui.send(level, I18n.t("vagrant.general.config_upgrade_messages",
-                               name: name,
-                               output: output))
-
-        # If we had errors, then we bail
-        raise Errors::ConfigUpgradeErrors if !config_errors.empty?
-      end
-
-      # Get the provider configuration from the final loaded configuration
-      provider_config = config.vm.get_provider_config(provider)
-
-      # Create machine data directory if it doesn't exist
-      # XXX: Permissions error here.
-      FileUtils.mkdir_p(data_path)
-
-      # Create the machine and cache it for future calls. This will also
-      # return the machine from this method.
-      return Machine.new(name, provider, provider_cls, provider_config,
-        provider_options, config, data_path, box, env, self)
-    end
-
-    # Returns the configuration for a single machine.
-    #
-    # When loading a box Vagrantfile, it will be prepended to the
-    # key order specified when initializing this class. Sub-machine
-    # and provider-specific overrides are appended at the end. The
-    # actual order is:
-    #
-    # - box
-    # - keys specified for #initialize
-    # - sub-machine
-    # - provider
-    #
-    # The return value is a hash with the following keys (symbols)
-    # and values:
-    #
-    #   - box: the {Box} backing the machine
-    #   - config: the actual configuration
-    #   - config_errors: list of errors, if any
-    #   - config_warnings: list of warnings, if any
-    #   - provider_cls: class of the provider backing the machine
-    #   - provider_options: options for the provider
-    #
-    # @param [Symbol] name Name of the machine.
-    # @param [Symbol] provider The provider the machine should
-    #   be backed by (required for provider overrides).
-    # @param [BoxCollection] boxes BoxCollection to look up the
-    #   box Vagrantfile.
-    # @return [Hash<Symbol, Object>] Various configuration parameters for a
-    #   machine. See the main documentation body for more info.
-    def machine_config(name, provider, boxes)
-      keys = @keys.dup
-
-      sub_machine = @config.vm.defined_vms[name]
-      if !sub_machine
-        raise Errors::MachineNotFound,
-          name: name, provider: provider
-      end
-
-      provider_plugin  = nil
-      provider_cls     = nil
-      provider_options = {}
-      box_formats      = nil
-      if provider != nil
-        provider_plugin  = Vagrant.plugin("2").manager.providers[provider]
-        if !provider_plugin
-          providers  = Vagrant.plugin("2").manager.providers.to_hash.keys
-          if providers
-            providers_str = providers.join(', ')
-          else
-            providers_str = "N/A"
-          end
-
-          if providers.include? provider.downcase
-            raise Errors::ProviderNotFoundSuggestion,
-              machine: name, provider: provider,
-              suggestion: provider.downcase, providers: providers_str
-          end
-
-          raise Errors::ProviderNotFound,
-            machine: name, provider: provider, providers: providers_str
-        end
-
-        provider_cls     = provider_plugin[0]
-        provider_options = provider_plugin[1]
-        box_formats      = provider_options[:box_format] || provider
-
-        # Test if the provider is usable or not
-        begin
-          provider_cls.usable?(true)
-        rescue Errors::VagrantError => e
-          raise Errors::ProviderNotUsable,
-            machine: name.to_s,
-            provider: provider.to_s,
-            message: e.to_s
-        end
-      end
-
-      # Add the sub-machine configuration to the loader and keys
-      vm_config_key = "#{object_id}_machine_#{name}"
-      @loader.set(vm_config_key, sub_machine.config_procs)
-      keys << vm_config_key
-
-      # Load once so that we can get the proper box value
-      config, config_warnings, config_errors = @loader.load(keys)
-
-      # Track the original box so we know if we changed
-      box = nil
-      original_box = config.vm.box
-      original_version = config.vm.box_version
-
-      # The proc below loads the box and provider overrides. This is
-      # in a proc because it may have to recurse if the provider override
-      # changes the box.
-      load_box_proc = lambda do
-        local_keys = keys.dup
-
-        # Load the box Vagrantfile, if there is one
-        if config.vm.box && boxes
-          box = boxes.find(config.vm.box, box_formats, config.vm.box_version)
-          if box
-            box_vagrantfile = find_vagrantfile(box.directory)
-            if box_vagrantfile
-              box_config_key =
-                "#{boxes.object_id}_#{box.name}_#{box.provider}".to_sym
-              @loader.set(box_config_key, box_vagrantfile)
-              local_keys.unshift(box_config_key)
-              config, config_warnings, config_errors = @loader.load(local_keys)
-            end
-          end
-        end
-
-        # Load provider overrides
-        provider_overrides = config.vm.get_provider_overrides(provider)
-        if !provider_overrides.empty?
-          config_key =
-            "#{object_id}_vm_#{name}_#{config.vm.box}_#{provider}".to_sym
-          @loader.set(config_key, provider_overrides)
-          local_keys << config_key
-          config, config_warnings, config_errors = @loader.load(local_keys)
-        end
-
-        # If the box changed, then we need to reload
-        if original_box != config.vm.box || original_version != config.vm.box_version
-          # TODO: infinite loop protection?
-
-          original_box = config.vm.box
-          original_version = config.vm.box_version
-          load_box_proc.call
-        end
-      end
-
-      # Load the box and provider overrides
-      load_box_proc.call
-
-      return {
-        box: box,
-        provider_cls: provider_cls,
-        provider_options: provider_options.dup,
-        config: config,
-        config_warnings: config_warnings,
-        config_errors: config_errors,
-      }
-    end
-
-    # Returns a list of the machines that are defined within this
-    # Vagrantfile.
-    #
-    # @return [Array<Symbol>]
-    def machine_names
-      @config.vm.defined_vm_keys.dup
-    end
-
-    # Returns a list of the machine names as well as the options that
-    # were specified for that machine.
-    #
-    # @return [Hash<Symbol, Hash>]
-    def machine_names_and_options
-      {}.tap do |r|
-        @config.vm.defined_vms.each do |name, subvm|
-          r[name] = subvm.options || {}
-        end
-      end
-    end
-
-    # Returns the name of the machine that is designated as the
-    # "primary."
-    #
-    # In the case of a single-machine environment, this is just the
-    # single machine name. In the case of a multi-machine environment,
-    # then this is the machine that is marked as primary, or nil if
-    # no primary machine was specified.
-    #
-    # @return [Symbol]
-    def primary_machine_name
-      # If it is a single machine environment, then return the name
-      return machine_names.first if machine_names.length == 1
-
-      # If it is a multi-machine environment, then return the primary
-      @config.vm.defined_vms.each do |name, subvm|
-        return name if subvm.options[:primary]
-      end
-
-      # If no primary was specified, nil it is
-      nil
-    end
-
-    protected
-
-    def find_vagrantfile(search_path)
-      ["Vagrantfile", "vagrantfile"].each do |vagrantfile|
-        current_path = search_path.join(vagrantfile)
-        return current_path if current_path.file?
-      end
-
-      nil
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module Vagrant
-  # This will always be up to date with the current version of Vagrant,
-  # since it is used to generate the gemspec and is also the source of
-  # the version for `vagrant -v`
-  VERSION = File.read(
-    File.expand_path("../../../version.txt", __FILE__)).chomp
-end