vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/prune.rb

@@ -1,128 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Prune < Vagrant.plugin("2", :command)
-        def execute
-          options = {}
-          options[:force] = false
-          options[:dry_run] = false
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box prune [options]"
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("-p PROVIDER", "--provider PROVIDER", String, "The specific provider type for the boxes to destroy.") do |p|
-              options[:provider] = p
-            end
-
-            o.on("-n", "--dry-run", "Only print the boxes that would be removed.") do |f|
-              options[:dry_run] = f
-            end
-
-            o.on("--name NAME", String, "The specific box name to check for outdated versions.") do |name|
-              options[:name] = name
-            end
-
-            o.on("-f", "--force", "Destroy without confirmation even when box is in use.") do |f|
-              options[:force] = f
-            end
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-
-          boxes = @env.boxes.all.sort
-          if boxes.empty?
-            return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), prefix: false)
-          end
-
-          delete_oldest_boxes(boxes, options[:provider], options[:force], options[:name], options[:dry_run])
-
-          # Success, exit status 0
-          0
-        end
-
-        private
-
-        def delete_oldest_boxes(boxes, only_provider, skip_confirm, only_name, dry_run)
-          # Find the longest box name
-          longest_box = boxes.max_by { |x| x[0].length }
-          longest_box_length = longest_box[0].length
-
-          # Hash map to keep track of newest versions
-          newest_boxes = Hash.new
-
-          # First find the newest version for every installed box
-          boxes.each do |name, version, provider|
-            next if only_provider and only_provider != provider.to_s
-            next if only_name and only_name != name
-
-            # Nested to make sure it works for boxes with different providers
-            if newest_boxes.has_key?(name)
-              if newest_boxes[name].has_key?(provider)
-                saved = Gem::Version.new(newest_boxes[name][provider])
-                current = Gem::Version.new(version)
-                if current > saved
-                  newest_boxes[name][provider] = version
-                end
-              else
-                newest_boxes[name][provider] = version
-              end
-            else
-              newest_boxes[name] = Hash.new
-              newest_boxes[name][provider] = version
-            end
-          end
-
-          @env.ui.info("The following boxes will be kept...");
-          newest_boxes.each do |name, providers|
-            providers.each do |provider, version|
-              @env.ui.info("#{name.ljust(longest_box_length)} (#{provider}, #{version})")
-
-              @env.ui.machine("box-name", name)
-              @env.ui.machine("box-provider", provider)
-              @env.ui.machine("box-version", version)
-            end
-          end
-
-          @env.ui.info("", prefix: false)
-          @env.ui.info("Checking for older boxes...");
-
-          # Track if we removed anything so the user can be informed
-          removed_any_box = false
-          boxes.each do |name, version, provider|
-            next if !newest_boxes.has_key?(name) or !newest_boxes[name].has_key?(provider)
-
-            current = Gem::Version.new(version)
-            saved = Gem::Version.new(newest_boxes[name][provider])
-            if current < saved
-              removed_any_box = true
-
-              # Use the remove box action
-              if dry_run
-                @env.ui.info("Would remove #{name} #{provider} #{version}")
-              else
-                @env.action_runner.run(Vagrant::Action.action_box_remove, {
-                    box_name: name,
-                    box_provider: provider,
-                    box_version: version,
-                    force_confirm_box_remove: skip_confirm,
-                    box_remove_all_versions: false,
-                })
-              end
-            end
-          end
-
-          if !removed_any_box
-            @env.ui.info("No old versions of boxes to remove...");
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/remove.rb

@@ -1,66 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Remove < Vagrant.plugin("2", :command)
-        def execute
-          options = {}
-          options[:force] = false
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box remove <name>"
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("-f", "--force", "Remove without confirmation.") do |f|
-              options[:force] = f
-            end
-
-            o.on("--provider PROVIDER", String,
-                 "The specific provider type for the box to remove") do |p|
-              options[:provider] = p
-            end
-
-            o.on("--box-version VERSION", String,
-                 "The specific version of the box to remove") do |v|
-              options[:version] = v
-            end
-
-            o.on("--all", "Remove all available versions of the box") do |a|
-              options[:all] = a
-            end
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          if argv.empty? || argv.length > 2
-            raise Vagrant::Errors::CLIInvalidUsage,
-              help: opts.help.chomp
-          end
-
-          if argv.length == 2
-            # @deprecated
-            @env.ui.warn("WARNING: The second argument to `vagrant box remove`")
-            @env.ui.warn("is deprecated. Please use the --provider flag. This")
-            @env.ui.warn("feature will stop working in the next version.")
-            options[:provider] = argv[1]
-          end
-
-          @env.action_runner.run(Vagrant::Action.action_box_remove, {
-            box_name:     argv[0],
-            box_provider: options[:provider],
-            box_version:  options[:version],
-            force_confirm_box_remove: options[:force],
-            box_remove_all_versions: options[:all],
-          })
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/repackage.rb

@@ -1,43 +0,0 @@
-require "fileutils"
-require 'optparse'
-require "pathname"
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Repackage < Vagrant.plugin("2", :command)
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box repackage <name> <provider> <version>"
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length != 3
-
-          box_name     = argv[0]
-          box_provider = argv[1].to_sym
-          box_version  = argv[2]
-
-          # Verify the box exists that we want to repackage
-          box = @env.boxes.find(box_name, box_provider, "= #{box_version}")
-          if !box
-            raise Vagrant::Errors::BoxNotFoundWithProviderAndVersion,
-              name: box_name,
-              provider: box_provider.to_s,
-              version: box_version
-          end
-
-          # Repackage the box
-          output_name = @env.vagrantfile.config.package.name || "package.box"
-          output_path = Pathname.new(File.expand_path(output_name, FileUtils.pwd))
-          box.repackage(output_path)
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/root.rb

@@ -1,94 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Root < Vagrant.plugin("2", :command)
-        def self.synopsis
-          "manages boxes: installation, removal, etc."
-        end
-
-        def initialize(argv, env)
-          super
-
-          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-          @subcommands = Vagrant::Registry.new
-          @subcommands.register(:add) do
-            require File.expand_path("../add", __FILE__)
-            Add
-          end
-
-          @subcommands.register(:list) do
-            require File.expand_path("../list", __FILE__)
-            List
-          end
-
-          @subcommands.register(:outdated) do
-            require_relative "outdated"
-            Outdated
-          end
-
-          @subcommands.register(:remove) do
-            require File.expand_path("../remove", __FILE__)
-            Remove
-          end
-
-          @subcommands.register(:prune) do
-            require_relative "prune"
-            Prune
-          end
-
-          @subcommands.register(:repackage) do
-            require File.expand_path("../repackage", __FILE__)
-            Repackage
-          end
-
-          @subcommands.register(:update) do
-            require_relative "update"
-            Update
-          end
-        end
-
-        def execute
-          if @main_args.include?("-h") || @main_args.include?("--help")
-            # Print the help for all the box commands.
-            return help
-          end
-
-          # If we reached this far then we must have a subcommand. If not,
-          # then we also just print the help and exit.
-          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
-          return help if !command_class || !@sub_command
-          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
-
-          # Initialize and execute the command class
-          command_class.new(@sub_args, @env).execute
-        end
-
-        # Prints the help out for this command
-        def help
-          opts = OptionParser.new do |opts|
-            opts.banner = "Usage: vagrant box <subcommand> [<args>]"
-            opts.separator ""
-            opts.separator "Available subcommands:"
-
-            # Add the available subcommands as separators in order to print them
-            # out as well.
-            keys = []
-            @subcommands.each { |key, value| keys << key.to_s }
-
-            keys.sort.each do |key|
-              opts.separator "     #{key}"
-            end
-
-            opts.separator ""
-            opts.separator "For help on any individual subcommand run `vagrant box <subcommand> -h`"
-          end
-
-          @env.ui.info(opts.help, prefix: false)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/command/update.rb

@@ -1,166 +0,0 @@
-require 'optparse'
-
-require_relative 'download_mixins'
-
-module VagrantPlugins
-  module CommandBox
-    module Command
-      class Update < Vagrant.plugin("2", :command)
-        include DownloadMixins
-
-        def execute
-          options = {}
-          download_options = {}
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant box update [options]"
-            o.separator ""
-            o.separator "Updates the box that is in use in the current Vagrant environment,"
-            o.separator "if there any updates available. This does not destroy/recreate the"
-            o.separator "machine, so you'll have to do that to see changes."
-            o.separator ""
-            o.separator "To update a specific box (not tied to a Vagrant environment), use the"
-            o.separator "--box flag."
-            o.separator ""
-            o.separator "Options:"
-            o.separator ""
-
-            o.on("--box BOX", String, "Update a specific box") do |b|
-              options[:box] = b
-            end
-
-            o.on("--provider PROVIDER", String, "Update box with specific provider") do |p|
-              options[:provider] = p.to_sym
-            end
-
-            o.on("-f", "--force", "Overwrite an existing box if it exists") do |f|
-              options[:force] = f
-            end
-
-            build_download_options(o, download_options)
-          end
-
-          argv = parse_options(opts)
-          return if !argv
-
-          if options[:box]
-            update_specific(options[:box], options[:provider], download_options, options[:force])
-          else
-            update_vms(argv, options[:provider], download_options, options[:force])
-          end
-
-          0
-        end
-
-        def update_specific(name, provider, download_options, force)
-          boxes = {}
-          @env.boxes.all.each do |n, v, p|
-            boxes[n] ||= {}
-            boxes[n][p] ||= []
-            boxes[n][p] << v
-          end
-
-          if !boxes[name]
-            raise Vagrant::Errors::BoxNotFound, name: name.to_s
-          end
-
-          if !provider
-            if boxes[name].length > 1
-              raise Vagrant::Errors::BoxUpdateMultiProvider,
-                name: name.to_s,
-                providers: boxes[name].keys.map(&:to_s).sort.join(", ")
-            end
-
-            provider = boxes[name].keys.first
-          elsif !boxes[name][provider]
-            raise Vagrant::Errors::BoxNotFoundWithProvider,
-              name: name.to_s,
-              provider: provider.to_s,
-              providers: boxes[name].keys.map(&:to_s).sort.join(", ")
-          end
-
-          to_update = [
-            [name, provider, boxes[name][provider].sort.last],
-          ]
-
-          to_update.each do |n, p, v|
-            box = @env.boxes.find(n, p, v)
-            box_update(box, "> #{v}", @env.ui, download_options, force)
-          end
-        end
-
-        def update_vms(argv, provider, download_options, force)
-          machines = {}
-
-          with_target_vms(argv, provider: provider) do |machine|
-            if !machine.config.vm.box
-              machine.ui.output(I18n.t(
-                "vagrant.errors.box_update_no_name"))
-              next
-            end
-
-            if !machine.box
-              machine.ui.output(I18n.t(
-                "vagrant.errors.box_update_no_box",
-                name: machine.config.vm.box))
-              next
-            end
-
-            name     = machine.box.name
-            provider = machine.box.provider
-            version  = machine.config.vm.box_version || machine.box.version
-
-            machines["#{name}_#{provider}_#{version}"] = machine
-          end
-
-          machines.each do |_, machine|
-            box = machine.box
-            version = machine.config.vm.box_version
-            # Get download options from machine configuration if not specified
-            # on the command line.
-            download_options[:ca_cert] ||= machine.config.vm.box_download_ca_cert
-            download_options[:ca_path] ||= machine.config.vm.box_download_ca_path
-            download_options[:client_cert] ||= machine.config.vm.box_download_client_cert
-            if download_options[:insecure].nil?
-              download_options[:insecure] = machine.config.vm.box_download_insecure
-            end
-            box_update(box, version, machine.ui, download_options, force)
-          end
-        end
-
-        def box_update(box, version, ui, download_options, force)
-          ui.output(I18n.t("vagrant.box_update_checking", name: box.name))
-          ui.detail("Latest installed version: #{box.version}")
-          ui.detail("Version constraints: #{version}")
-          ui.detail("Provider: #{box.provider}")
-
-          update = box.has_update?(version, download_options: download_options)
-          if !update
-            ui.success(I18n.t(
-              "vagrant.box_up_to_date_single",
-              name: box.name, version: box.version))
-            return
-          end
-
-          ui.output(I18n.t(
-            "vagrant.box_updating",
-            name: update[0].name,
-            provider: update[2].name,
-            old: box.version,
-            new: update[1].version))
-          @env.action_runner.run(Vagrant::Action.action_box_add, {
-            box_url: box.metadata_url,
-            box_provider: update[2].name,
-            box_version: update[1].version,
-            ui: ui,
-            box_force: force,
-            box_client_cert: download_options[:client_cert],
-            box_download_ca_cert: download_options[:ca_cert],
-            box_download_ca_path: download_options[:ca_path],
-            box_download_insecure: download_options[:insecure]
-          })
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/box/plugin.rb

@@ -1,15 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandBox
-    class Plugin < Vagrant.plugin("2")
-      name "box command"
-      description "The `box` command gives you a way to manage boxes."
-
-      command("box") do
-        require File.expand_path("../command/root", __FILE__)
-        Command::Root
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/cap/command.rb

@@ -1,75 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandCap
-    class Command < Vagrant.plugin("2", :command)
-      def self.synopsis
-        "checks and executes capability"
-      end
-
-      def execute
-        options = {}
-        options[:check] = false
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant cap [options] TYPE NAME [args]"
-          o.separator ""
-          o.separator "This is an advanced command. If you don't know what this"
-          o.separator "does and you aren't explicitly trying to use it, you probably"
-          o.separator "don't want to use this."
-          o.separator ""
-          o.separator "This command checks or executes arbitrary capabilities that"
-          o.separator "Vagrant has for hosts, guests, and providers."
-          o.separator ""
-          o.separator "Options:"
-          o.separator ""
-
-          o.on("--check", "Only checks for a capability, does not execute") do |f|
-            options[:check] = f
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-        if argv.length < 2
-          raise Vagrant::Errors::CLIInvalidUsage,
-            help: opts.help.chomp
-        end
-
-        type = argv.shift.to_sym
-        name = argv.shift.to_sym
-
-        # Get the proper capability host to check
-        cap_host = nil
-        if type == :host
-          cap_host = @env.host
-        else
-          with_target_vms([]) do |vm|
-            cap_host = case type
-                       when :provider
-                         vm.provider
-                       when :guest
-                         vm.guest
-                       else
-                         raise Vagrant::Errors::CLIInvalidUsage,
-                           help: opts.help.chomp
-                       end
-          end
-        end
-
-        # If we're just checking, then just return exit codes
-        if options[:check]
-          return 0 if cap_host.capability?(name)
-          return 1
-        end
-
-        # Otherwise, call it
-        cap_host.capability(name, *argv)
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/cap/plugin.rb

@@ -1,17 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandCap
-    class Plugin < Vagrant.plugin("2")
-      name "cap command"
-      description <<-DESC
-      The `cap` command checks and executes arbitrary capabilities.
-      DESC
-
-      command("cap", primary: false) do
-        require_relative "command"
-        Command
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/destroy/command.rb

@@ -1,75 +0,0 @@
-module VagrantPlugins
-  module CommandDestroy
-    class Command < Vagrant.plugin("2", :command)
-      def self.synopsis
-        "stops and deletes all traces of the vagrant machine"
-      end
-
-      def execute
-        options = {}
-        options[:force] = false
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant destroy [options] [name|id]"
-          o.separator ""
-          o.separator "Options:"
-          o.separator ""
-
-          o.on("-f", "--force", "Destroy without confirmation.") do |f|
-            options[:force] = f
-          end
-
-          o.on("--[no-]parallel",
-               "Enable or disable parallelism if provider supports it (automatically enables force)") do |p|
-            options[:parallel] = p
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        if options[:parallel] && !options[:force]
-          @env.ui.warn(I18n.t("vagrant.commands.destroy.warning"))
-          sleep(5)
-          options[:force] = true
-        end
-
-        @logger.debug("'Destroy' each target VM...")
-
-        machines = []
-        init_states = {}
-        declined = 0
-
-        @env.batch(options[:parallel]) do |batch|
-          with_target_vms(argv, reverse: true) do |vm|
-            # gather states to be checked after destroy
-            init_states[vm.name] = vm.state.id
-            machines << vm
-
-            batch.action(vm, :destroy, force_confirm_destroy: options[:force])
-          end
-        end
-
-        machines.each do |m|
-          if m.state.id == init_states[m.name]
-            declined += 1
-          end
-        end
-
-        # Nothing was declined
-        return 0 if declined == 0
-
-        # Everything was declined, and all states are `not_created`
-        return 0 if declined == machines.length &&
-                    declined == init_states.values.count(:not_created)
-
-        # Everything was declined, state was not changed
-        return 1 if declined == machines.length
-
-        # Some was declined
-        return 2
-      end
-    end
-  end
-end