vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,196 +0,0 @@
-require "pathname"
-require "set"
-
-require_relative "../bundler"
-require_relative "../shared_helpers"
-require_relative "state_file"
-
-module Vagrant
-  module Plugin
-    # The Manager helps with installing, listing, and initializing plugins.
-    class Manager
-      # Returns the path to the [StateFile] for user plugins.
-      #
-      # @return [Pathname]
-      def self.user_plugins_file
-        Vagrant.user_data_path.join("plugins.json")
-      end
-
-      # Returns the path to the [StateFile] for system plugins.
-      def self.system_plugins_file
-        dir = Vagrant.installer_embedded_dir
-        return nil if !dir
-        Pathname.new(dir).join("plugins.json")
-      end
-
-      def self.instance
-        @instance ||= self.new(user_plugins_file)
-      end
-
-      # @param [Pathname] user_file
-      def initialize(user_file)
-        @user_file   = StateFile.new(user_file)
-
-        system_path  = self.class.system_plugins_file
-        @system_file = nil
-        @system_file = StateFile.new(system_path) if system_path && system_path.file?
-      end
-
-      # Installs another plugin into our gem directory.
-      #
-      # @param [String] name Name of the plugin (gem)
-      # @return [Gem::Specification]
-      def install_plugin(name, **opts)
-        local = false
-        if name =~ /\.gem$/
-          # If this is a gem file, then we install that gem locally.
-          local_spec = Vagrant::Bundler.instance.install_local(name, opts)
-          name       = local_spec.name
-          opts[:version] = local_spec.version.to_s
-        end
-
-        plugins = installed_plugins
-        plugins[name] = {
-          "require"     => opts[:require],
-          "gem_version" => opts[:version],
-          "sources"     => opts[:sources],
-        }
-
-        if local_spec.nil?
-          result = nil
-          install_lambda = lambda do
-            Vagrant::Bundler.instance.install(plugins, local).each do |spec|
-              next if spec.name != name
-              next if result && result.version >= spec.version
-              result = spec
-            end
-          end
-
-          if opts[:verbose]
-            Vagrant::Bundler.instance.verbose(&install_lambda)
-          else
-            install_lambda.call
-          end
-        else
-          result = local_spec
-        end
-        # Add the plugin to the state file
-        @user_file.add_plugin(
-          result.name,
-          version: opts[:version],
-          require: opts[:require],
-          sources: opts[:sources],
-          installed_gem_version: result.version.to_s
-        )
-
-        # After install clean plugin gems to remove any cruft. This is useful
-        # for removing outdated dependencies or other versions of an installed
-        # plugin if the plugin is upgraded/downgraded
-        Vagrant::Bundler.instance.clean(installed_plugins)
-        result
-      rescue Gem::GemNotFoundException
-        raise Errors::PluginGemNotFound, name: name
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # Uninstalls the plugin with the given name.
-      #
-      # @param [String] name
-      def uninstall_plugin(name)
-        if @system_file
-          if !@user_file.has_plugin?(name) && @system_file.has_plugin?(name)
-            raise Errors::PluginUninstallSystem,
-              name: name
-          end
-        end
-
-        @user_file.remove_plugin(name)
-
-        # Clean the environment, removing any old plugins
-        Vagrant::Bundler.instance.clean(installed_plugins)
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # Updates all or a specific set of plugins.
-      def update_plugins(specific)
-        result = Vagrant::Bundler.instance.update(installed_plugins, specific)
-        installed_plugins.each do |name, info|
-          matching_spec = result.detect{|s| s.name == name}
-          info = Hash[
-            info.map do |key, value|
-              [key.to_sym, value]
-            end
-          ]
-          if matching_spec
-            @user_file.add_plugin(name, **info.merge(
-              version: "> 0",
-              installed_gem_version: matching_spec.version.to_s
-            ))
-          end
-        end
-        Vagrant::Bundler.instance.clean(installed_plugins)
-        result
-      rescue Gem::Exception => e
-        raise Errors::BundlerError, message: e.to_s
-      end
-
-      # This returns the list of plugins that should be enabled.
-      #
-      # @return [Hash]
-      def installed_plugins
-        system = {}
-        if @system_file
-          @system_file.installed_plugins.each do |k, v|
-            system[k] = v.merge("system" => true)
-          end
-        end
-        plugin_list = Util::DeepMerge.deep_merge(system, @user_file.installed_plugins)
-
-        # Sort plugins by name
-        Hash[
-          plugin_list.map{|plugin_name, plugin_info|
-            [plugin_name, plugin_info]
-          }.sort_by(&:first)
-        ]
-      end
-
-      # This returns the list of plugins that are installed as
-      # Gem::Specifications.
-      #
-      # @return [Array<Gem::Specification>]
-      def installed_specs
-        installed_plugin_info = installed_plugins
-        installed = Set.new(installed_plugin_info.keys)
-        installed_versions = Hash[
-          installed_plugin_info.map{|plugin_name, plugin_info|
-            gem_version = plugin_info["gem_version"].to_s
-            gem_version = "> 0" if gem_version.empty?
-            [plugin_name, Gem::Requirement.new(gem_version)]
-          }
-        ]
-
-        # Go through the plugins installed in this environment and
-        # get the latest version of each.
-        installed_map = {}
-        Gem::Specification.find_all.each do |spec|
-          # Ignore specs that aren't in our installed list
-          next if !installed.include?(spec.name)
-
-          next if installed_versions[spec.name] &&
-            !installed_versions[spec.name].satisfied_by?(spec.version)
-
-          # If we already have a newer version in our list of installed,
-          # then ignore it
-          next if installed_map.key?(spec.name) &&
-            installed_map[spec.name].version >= spec.version
-
-          installed_map[spec.name] = spec
-        end
-
-        installed_map.values
-      end
-    end
-  end
-end

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

@@ -1,128 +0,0 @@
-require "json"
-require "fileutils"
-require "tempfile"
-
-module Vagrant
-  module Plugin
-    # This is a helper to deal with the plugin state file that Vagrant
-    # uses to track what plugins are installed and activated and such.
-    class StateFile
-      def initialize(path)
-        @path = path
-
-        @data = {}
-        if @path.exist?
-          begin
-            @data = JSON.parse(@path.read)
-          rescue JSON::ParserError => e
-            raise Vagrant::Errors::PluginStateFileParseError,
-              path: path, message: e.message
-          end
-
-          upgrade_v0! if !@data["version"]
-        end
-
-        @data["version"] ||= "1"
-        @data["installed"] ||= {}
-      end
-
-      # Add a plugin that is installed to the state file.
-      #
-      # @param [String] name The name of the plugin
-      def add_plugin(name, **opts)
-        @data["installed"][name] = {
-          "ruby_version"          => RUBY_VERSION,
-          "vagrant_version"       => Vagrant::VERSION,
-          "gem_version"           => opts[:version] || "",
-          "require"               => opts[:require] || "",
-          "sources"               => opts[:sources] || [],
-          "installed_gem_version" => opts[:installed_gem_version]
-        }
-
-        save!
-      end
-
-      # Adds a RubyGems index source to look up gems.
-      #
-      # @param [String] url URL of the source.
-      def add_source(url)
-        @data["sources"] ||= []
-        @data["sources"] << url if !@data["sources"].include?(url)
-        save!
-      end
-
-      # This returns a hash of installed plugins according to the state
-      # file. Note that this may _not_ directly match over to actually
-      # installed gems.
-      #
-      # @return [Hash]
-      def installed_plugins
-        @data["installed"]
-      end
-
-      # Returns true/false if the plugin is present in this state file.
-      #
-      # @return [Boolean]
-      def has_plugin?(name)
-        @data["installed"].key?(name)
-      end
-
-      # Remove a plugin that is installed from the state file.
-      #
-      # @param [String] name The name of the plugin.
-      def remove_plugin(name)
-        @data["installed"].delete(name)
-        save!
-      end
-
-      # Remove a source for RubyGems.
-      #
-      # @param [String] url URL of the source
-      def remove_source(url)
-        @data["sources"] ||= []
-        @data["sources"].delete(url)
-        save!
-      end
-
-      # Returns the list of RubyGems sources that will be searched for
-      # plugins.
-      #
-      # @return [Array<String>]
-      def sources
-        @data["sources"] || []
-      end
-
-      # This saves the state back into the state file.
-      def save!
-        Tempfile.open(@path.basename.to_s, @path.dirname.to_s) do |f|
-          f.binmode
-          f.write(JSON.dump(@data))
-          f.fsync
-          f.chmod(0644)
-          f.close
-          FileUtils.mv(f.path, @path)
-        end
-      end
-
-      protected
-
-      # This upgrades the internal data representation from V0 (the initial
-      # version) to V1.
-      def upgrade_v0!
-        @data["version"] = "1"
-
-        new_installed = {}
-        (@data["installed"] || []).each do |plugin|
-          new_installed[plugin] = {
-            "ruby_version"    => "0",
-            "vagrant_version" => "0",
-          }
-        end
-
-        @data["installed"] = new_installed
-
-        save!
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v1/command.rb

@@ -1,169 +0,0 @@
-require 'log4r'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a CLI command.
-      class Command
-        include Util::SafePuts
-
-        def initialize(argv, env)
-          @argv = argv
-          @env  = env
-          @logger = Log4r::Logger.new("vagrant::command::#{self.class.to_s.downcase}")
-        end
-
-        # This is what is called on the class to actually execute it. Any
-        # subclasses should implement this method and do any option parsing
-        # and validation here.
-        def execute
-        end
-
-        protected
-
-        # Parses the options given an OptionParser instance.
-        #
-        # This is a convenience method that properly handles duping the
-        # originally argv array so that it is not destroyed.
-        #
-        # This method will also automatically detect "-h" and "--help"
-        # and print help. And if any invalid options are detected, the help
-        # will be printed, as well.
-        #
-        # If this method returns `nil`, then you should assume that help
-        # was printed and parsing failed.
-        def parse_options(opts=nil)
-          # Creating a shallow copy of the arguments so the OptionParser
-          # doesn't destroy the originals.
-          argv = @argv.dup
-
-          # Default opts to a blank optionparser if none is given
-          opts ||= OptionParser.new
-
-          # Add the help option, which must be on every command.
-          opts.on_tail("-h", "--help", "Print this help") do
-            safe_puts(opts.help)
-            return nil
-          end
-
-          opts.parse!(argv)
-          return argv
-        rescue OptionParser::InvalidOption
-          raise Errors::CLIInvalidOptions, help: opts.help.chomp
-        end
-
-        # Yields a VM for each target VM for the command.
-        #
-        # This is a convenience method for easily implementing methods that
-        # take a target VM (in the case of multi-VM) or every VM if no
-        # specific VM name is specified.
-        #
-        # @param [String] name The name of the VM. Nil if every VM.
-        # @param [Boolean] single_target If true, then an exception will be
-        #   raised if more than one target is found.
-        def with_target_vms(names=nil, options=nil)
-          # Using VMs requires a Vagrant environment to be properly setup
-          raise Errors::NoEnvironmentError if !@env.root_path
-
-          # Setup the options hash
-          options ||= {}
-
-          # Require that names be an array
-          names ||= []
-          names = [names] if !names.is_a?(Array)
-
-          # First determine the proper array of VMs.
-          vms = []
-          if names.length > 0
-            names.each do |name|
-              if pattern = name[/^\/(.+?)\/$/, 1]
-                # This is a regular expression name, so we convert to a regular
-                # expression and allow that sort of matching.
-                regex = Regexp.new(pattern)
-
-                @env.vms.each do |name, vm|
-                  vms << vm if name =~ regex
-                end
-
-                raise Errors::VMNoMatchError if vms.empty?
-              else
-                # String name, just look for a specific VM
-                vms << @env.vms[name.to_sym]
-                raise Errors::VMNotFoundError, name: name if !vms[0]
-              end
-            end
-          else
-            vms = @env.vms_ordered
-          end
-
-          # Make sure we're only working with one VM if single target
-          if options[:single_target] && vms.length != 1
-            vm = @env.primary_vm
-            raise Errors::MultiVMTargetRequired if !vm
-            vms = [vm]
-          end
-
-          # If we asked for reversed ordering, then reverse it
-          vms.reverse! if options[:reverse]
-
-          # Go through each VM and yield it!
-          vms.each do |old_vm|
-            # We get a new VM from the environment here to avoid potentially
-            # stale VMs (if there was a config reload on the environment
-            # or something).
-            vm = @env.vms[old_vm.name]
-            yield vm
-          end
-        end
-
-        # This method will split the argv given into three parts: the
-        # flags to this command, the subcommand, and the flags to the
-        # subcommand. For example:
-        #
-        #     -v status -h -v
-        #
-        # The above would yield 3 parts:
-        #
-        #     ["-v"]
-        #     "status"
-        #     ["-h", "-v"]
-        #
-        # These parts are useful because the first is a list of arguments
-        # given to the current command, the second is a subcommand, and the
-        # third are the commands given to the subcommand.
-        #
-        # @return [Array] The three parts.
-        def split_main_and_subcommand(argv)
-          # Initialize return variables
-          main_args   = nil
-          sub_command = nil
-          sub_args    = []
-
-          # We split the arguments into two: One set containing any
-          # flags before a word, and then the rest. The rest are what
-          # get actually sent on to the subcommand.
-          argv.each_index do |i|
-            if !argv[i].start_with?("-")
-              # We found the beginning of the sub command. Split the
-              # args up.
-              main_args   = argv[0, i]
-              sub_command = argv[i]
-              sub_args    = argv[i + 1, argv.length - i + 1]
-
-              # Break so we don't find the next non flag and shift our
-              # main args.
-              break
-            end
-          end
-
-          # Handle the case that argv was empty or didn't contain any subcommand
-          main_args = argv.dup if main_args.nil?
-
-          return [main_args, sub_command, sub_args]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/lib/vagrant/plugin/v1/communicator.rb

@@ -1,98 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # Base class for a communicator in Vagrant. A communicator is
-      # responsible for communicating with a machine in some way. There
-      # are various stages of Vagrant that require things such as uploading
-      # files to the machine, executing shell commands, etc. Implementors
-      # of this class are expected to provide this functionality in some
-      # way.
-      #
-      # Note that a communicator must provide **all** of the methods
-      # in this base class. There is currently no way for one communicator
-      # to provide say a more efficient way of uploading a file, but not
-      # provide shell execution. This sort of thing will come in a future
-      # version.
-      class Communicator
-        # This returns true/false depending on if the given machine
-        # can be communicated with using this communicator. If this returns
-        # `true`, then this class will be used as the primary communication
-        # method for the machine.
-        #
-        # @return [Boolean]
-        def self.match?(machine)
-          false
-        end
-
-        # Initializes the communicator with the machine that we will be
-        # communicating with. This base method does nothing (it doesn't
-        # even store the machine in an instance variable for you), so you're
-        # expected to override this and do something with the machine if
-        # you care about it.
-        #
-        # @param [Machine] machine The machine this instance is expected to
-        #   communicate with.
-        def initialize(machine)
-        end
-
-        # Checks if the target machine is ready for communication. If this
-        # returns true, then all the other methods for communicating with
-        # the machine are expected to be functional.
-        #
-        # @return [Boolean]
-        def ready?
-          false
-        end
-
-        # Download a file from the remote machine to the local machine.
-        #
-        # @param [String] from Path of the file on the remote machine.
-        # @param [String] to Path of where to save the file locally.
-        def download(from, to)
-        end
-
-        # Upload a file to the remote machine.
-        #
-        # @param [String] from Path of the file locally to upload.
-        # @param [String] to Path of where to save the file on the remote
-        #   machine.
-        def upload(from, to)
-        end
-
-        # Execute a command on the remote machine. The exact semantics
-        # of this method are up to the implementor, but in general the
-        # users of this class will expect this to be a shell.
-        #
-        # This method gives you no way to write data back to the remote
-        # machine, so only execute commands that don't expect input.
-        #
-        # @param [String] command Command to execute.
-        # @yield [type, data] Realtime output of the command being executed.
-        # @yieldparam [String] type Type of the output. This can be
-        #   `:stdout`, `:stderr`, etc. The exact types are up to the
-        #   implementor.
-        # @yieldparam [String] data Data for the given output.
-        # @return [Integer] Exit code of the command.
-        def execute(command, opts=nil)
-        end
-
-        # Executes a command on the remote machine with administrative
-        # privileges. See {#execute} for documentation, as the API is the
-        # same.
-        #
-        # @see #execute
-        def sudo(command, opts=nil)
-        end
-
-        # Executes a command and returns true if the command succeeded,
-        # and false otherwise. By default, this executes as a normal user,
-        # and it is up to the communicator implementation if they expose an
-        # option for running tests as an administrator.
-        #
-        # @see #execute
-        def test(command, opts=nil)
-        end
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-module Vagrant
-  module Plugin
-    module V1
-      # This is the base class for a configuration key defined for
-      # V1. Any configuration key plugins for V1 should inherit from this
-      # class.
-      class Config
-        # This constant represents an unset value. This is useful so it is
-        # possible to know the difference between a configuration value that
-        # was never set, and a value that is nil (explicitly). Best practice
-        # is to initialize all variables to this value, then the {#merge}
-        # method below will "just work" in many cases.
-        UNSET_VALUE = Object.new
-
-        # This is called as a last-minute hook that allows the configuration
-        # object to finalize itself before it will be put into use. This is
-        # a useful place to do some defaults in the case the user didn't
-        # configure something or so on.
-        #
-        # An example of where this sort of thing is used or has been used:
-        # the "vm" configuration key uses this to make sure that at least
-        # one sub-VM has been defined: the default VM.
-        #
-        # The configuration object is expected to mutate itself.
-        def finalize!
-          # Default implementation is to do nothing.
-        end
-
-        # Merge another configuration object into this one. This assumes that
-        # the other object is the same class as this one. This should not
-        # mutate this object, but instead should return a new, merged object.
-        #
-        # The default implementation will simply iterate over the instance
-        # variables and merge them together, with this object overriding
-        # any conflicting instance variables of the older object. Instance
-        # variables starting with "__" (double underscores) will be ignored.
-        # This lets you set some sort of instance-specific state on your
-        # configuration keys without them being merged together later.
-        #
-        # @param [Object] other The other configuration object to merge from,
-        #   this must be the same type of object as this one.
-        # @return [Object] The merged object.
-        def merge(other)
-          result = self.class.new
-
-          # Set all of our instance variables on the new class
-          [self, other].each do |obj|
-            obj.instance_variables.each do |key|
-              # Ignore keys that start with a double underscore. This allows
-              # configuration classes to still hold around internal state
-              # that isn't propagated.
-              if !key.to_s.start_with?("@__")
-                result.instance_variable_set(key, obj.instance_variable_get(key))
-              end
-            end
-          end
-
-          result
-        end
-
-        # Allows setting options from a hash. By default this simply calls
-        # the `#{key}=` method on the config class with the value, which is
-        # the expected behavior most of the time.
-        #
-        # This is expected to mutate itself.
-        #
-        # @param [Hash] options A hash of options to set on this configuration
-        #   key.
-        def set_options(options)
-          options.each do |key, value|
-            send("#{key}=", value)
-          end
-        end
-
-        # Converts this configuration object to JSON.
-        def to_json(*a)
-          instance_variables_hash.to_json(*a)
-        end
-
-        # Returns the instance variables as a hash of key-value pairs.
-        def instance_variables_hash
-          instance_variables.inject({}) do |acc, iv|
-            acc[iv.to_s[1..-1]] = instance_variable_get(iv)
-            acc
-          end
-        end
-
-        # This is called to upgrade this V1 config to V2. The parameter given
-        # is the full V2 configuration object, so you can do anything to it
-        # that you want.
-        #
-        # No return value is expected, modifications should be made directly
-        # to the new V2 object.
-        #
-        # @param [V2::Root] new
-        def upgrade(new)
-        end
-
-        # Called after the configuration is finalized and loaded to validate
-        # this object.
-        #
-        # @param [Environment] env Vagrant::Environment object of the
-        #   environment that this configuration has been loaded into. This
-        #   gives you convenient access to things like the the root path
-        #   and so on.
-        # @param [ErrorRecorder] errors
-        def validate(env, errors)
-        end
-      end
-    end
-  end
-end