vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,73 +0,0 @@
-require "vagrant/plugin/manager"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware lists all the installed plugins.
-      #
-      # This is a bit more complicated than simply listing installed
-      # gems or what is in the state file as installed. Instead, this
-      # actually compares installed gems with what the state file claims
-      # is installed, and outputs the appropriate truly installed
-      # plugins.
-      class ListPlugins
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          manager = Vagrant::Plugin::Manager.instance
-          plugins = manager.installed_plugins
-          specs   = Hash[
-            manager.installed_specs.map do |spec|
-              [spec.name, spec]
-            end
-          ]
-
-          # Output!
-          if specs.empty?
-            env[:ui].info(I18n.t("vagrant.commands.plugin.no_plugins"))
-            return @app.call(env)
-          end
-
-          plugins.each do |plugin_name, plugin|
-
-            spec = specs[plugin_name]
-            next if spec.nil?
-
-            system = ""
-            system = ", system" if plugin && plugin["system"]
-            env[:ui].info "#{spec.name} (#{spec.version}#{system})"
-            env[:ui].machine("plugin-name", spec.name)
-            env[:ui].machine(
-              "plugin-version",
-              "#{spec.version}#{system}",
-              target: spec.name)
-
-            if plugin["gem_version"] && plugin["gem_version"] != ""
-              env[:ui].info(I18n.t(
-                "vagrant.commands.plugin.plugin_version",
-                version: plugin["gem_version"]))
-              env[:ui].machine(
-                "plugin-version-constraint",
-                plugin["gem_version"],
-                target: spec.name)
-            end
-
-            if plugin["require"] && plugin["require"] != ""
-              env[:ui].info(I18n.t(
-                "vagrant.commands.plugin.plugin_require",
-                require: plugin["require"]))
-              env[:ui].machine(
-                "plugin-custom-entrypoint",
-                plugin["require"],
-                target: spec.name)
-            end
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require "vagrant/plugin/manager"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This class checks to see if the plugin is installed already, and
-      # if so, raises an exception/error to output to the user.
-      class PluginExistsCheck
-        def initialize(app, env)
-          @app    = app
-        end
-
-        def call(env)
-          installed = Vagrant::Plugin::Manager.instance.installed_plugins
-          if !installed.key?(env[:plugin_name])
-            raise Vagrant::Errors::PluginNotInstalled,
-              name: env[:plugin_name]
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require "vagrant/plugin/manager"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware attempts to repair installed plugins.
-      #
-      # In general, if plugins are failing to properly load the
-      # core issue will likely be one of two issues:
-      #   1. manual modifications within ~/.vagrant.d/
-      #   2. vagrant upgrade
-      # Running an install on configured plugin set will most
-      # likely fix these issues, which is all this action does.
-      class RepairPlugins
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::plugins::plugincommand::repair")
-        end
-
-        def call(env)
-          env[:ui].info(I18n.t("vagrant.commands.plugin.repairing"))
-          plugins = Vagrant::Plugin::Manager.instance.installed_plugins
-          begin
-            Vagrant::Bundler.instance.init!(plugins, :repair)
-            env[:ui].info(I18n.t("vagrant.commands.plugin.repair_complete"))
-          rescue Exception => e
-            @logger.error("Failed to repair user installed plugins: #{e.class} - #{e}")
-            e.backtrace.each do |backtrace_line|
-              @logger.debug(backtrace_line)
-            end
-            env[:ui].error(I18n.t("vagrant.commands.plugin.repair_failed", message: e.message))
-          end
-          # Continue
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware uninstalls a plugin by simply removing it from
-      # the state file. Running a {PruneGems} after should properly remove
-      # it from the gem index.
-      class UninstallPlugin
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # Remove it!
-          env[:ui].info(I18n.t("vagrant.commands.plugin.uninstalling",
-                               name: env[:plugin_name]))
-
-          manager = Vagrant::Plugin::Manager.instance
-          manager.uninstall_plugin(env[:plugin_name])
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require "vagrant/plugin/manager"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      class UpdateGems
-        def initialize(app, env)
-          @app    = app
-        end
-
-        def call(env)
-          names = env[:plugin_name] || []
-
-          if names.empty?
-            env[:ui].info(I18n.t("vagrant.commands.plugin.updating"))
-          else
-            env[:ui].info(I18n.t("vagrant.commands.plugin.updating_specific",
-                                 names: names.join(", ")))
-          end
-
-          manager = Vagrant::Plugin::Manager.instance
-          installed_plugins = manager.installed_plugins
-          new_specs       = manager.update_plugins(names)
-          updated_plugins = manager.installed_plugins
-
-          updated = {}
-          installed_plugins.each do |name, info|
-            update = updated_plugins[name]
-            if update && update["installed_gem_version"] != info["installed_gem_version"]
-              updated[name] = update["installed_gem_version"]
-            end
-          end
-
-          if updated.empty?
-            env[:ui].success(I18n.t("vagrant.commands.plugin.up_to_date"))
-          end
-
-          updated.each do |name, version|
-            env[:ui].success(I18n.t("vagrant.commands.plugin.updated",
-                                    name: name, version: version.to_s))
-          end
-
-          # Continue
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require "pathname"
-
-require "vagrant/action/builder"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Action
-      # This middleware sequence will remove all plugins.
-      def self.action_expunge
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use ExpungePlugins
-        end
-      end
-
-      # This middleware sequence will install a plugin.
-      def self.action_install
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use InstallGem
-        end
-      end
-
-      # This middleware sequence licenses paid addons.
-      def self.action_license
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use PluginExistsCheck
-          b.use LicensePlugin
-        end
-      end
-
-      # This middleware sequence will list all installed plugins.
-      def self.action_list
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use ListPlugins
-        end
-      end
-
-      # This middleware sequence will repair installed plugins.
-      def self.action_repair
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use RepairPlugins
-        end
-      end
-
-      # This middleware sequence will uninstall a plugin.
-      def self.action_uninstall
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use PluginExistsCheck
-          b.use UninstallPlugin
-        end
-      end
-
-      # This middleware sequence will update a plugin.
-      def self.action_update
-        Vagrant::Action::Builder.new.tap do |b|
-          b.use UpdateGems
-        end
-      end
-
-      # The autoload farm
-      action_root = Pathname.new(File.expand_path("../action", __FILE__))
-      autoload :ExpungePlugins, action_root.join("expunge_plugins")
-      autoload :InstallGem, action_root.join("install_gem")
-      autoload :LicensePlugin, action_root.join("license_plugin")
-      autoload :ListPlugins, action_root.join("list_plugins")
-      autoload :PluginExistsCheck, action_root.join("plugin_exists_check")
-      autoload :RepairPlugins, action_root.join("repair_plugins")
-      autoload :UninstallPlugin, action_root.join("uninstall_plugin")
-      autoload :UpdateGems, action_root.join("update_gems")
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "vagrant/plugin/state_file"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Base < Vagrant.plugin("2", :command)
-        # This is a helper for executing an action sequence with the proper
-        # environment hash setup so that the plugin specific helpers are
-        # in.
-        #
-        # @param [Object] callable the Middleware callable
-        # @param [Hash] env Extra environment hash that is merged in.
-        def action(callable, env=nil)
-          @env.action_runner.run(callable, env)
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Expunge < Base
-        def execute
-          options = {}
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin expunge [-h]"
-
-            o.on("--force", "Do not prompt for confirmation") do |force|
-              options[:force] = force
-            end
-
-            o.on("--reinstall", "Reinstall current plugins after expunge") do |reinstall|
-              options[:reinstall] = reinstall
-            end
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
-
-          plugins = Vagrant::Plugin::Manager.instance.installed_plugins
-
-          if !options[:reinstall] && !options[:force] && !plugins.empty?
-            result = nil
-            attempts = 0
-            while attempts < 5 && result.nil?
-              attempts += 1
-              result = @env.ui.ask(
-                I18n.t("vagrant.commands.plugin.expunge_request_reinstall") +
-                  " [N]: "
-              )
-              result = result.to_s.downcase.strip
-              result = "n" if result.empty?
-              if !["y", "yes", "n", "no"].include?(result)
-                result = nil
-                @env.ui.error("Please answer Y or N")
-              else
-                result = result[0,1]
-              end
-            end
-            options[:reinstall] = result == "y"
-          end
-
-          # Remove all installed user plugins
-          action(Action.action_expunge, options)
-
-          if options[:reinstall]
-            @env.ui.info(I18n.t("vagrant.commands.plugin.expunge_reinstall"))
-            plugins.each do |plugin_name, plugin_info|
-              next if plugin_info["system"] # system plugins do not require re-install
-              # Rebuild information hash to use symbols
-              plugin_info = Hash[
-                plugin_info.map do |key, value|
-                  ["plugin_#{key}".to_sym, value]
-                end
-              ]
-              action(
-                Action.action_install,
-                plugin_info.merge(
-                  plugin_name: plugin_name
-                )
-              )
-            end
-          end
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-require_relative "mixin_install_opts"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Install < Base
-        include MixinInstallOpts
-
-        def execute
-          options = { verbose: false }
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin install <name>... [-h]"
-            o.separator ""
-            build_install_opts(o, options)
-
-            o.on("--verbose", "Enable verbose output for plugin installation") do |v|
-              options[:verbose] = v
-            end
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length < 1
-
-          # Install the gem
-          argv.each do |name|
-            action(Action.action_install, {
-              plugin_entry_point: options[:entry_point],
-              plugin_version:     options[:plugin_version],
-              plugin_sources:     options[:plugin_sources],
-              plugin_name:        name,
-              plugin_verbose:     options[:verbose]
-            })
-          end
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class License < Base
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin license <name> <license-file> [-h]"
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length < 2
-
-          # License the plugin
-          action(Action.action_license, {
-            plugin_license_path: argv[1],
-            plugin_name:         argv[0]
-          })
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class List < Base
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin list [-h]"
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
-
-          # List the installed plugins
-          action(Action.action_list)
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      module MixinInstallOpts
-        def build_install_opts(o, options)
-          options[:plugin_sources] = Vagrant::Bundler::DEFAULT_GEM_SOURCES.dup
-
-          o.on("--entry-point NAME", String,
-               "The name of the entry point file for loading the plugin.") do |entry_point|
-            options[:entry_point] = entry_point
-          end
-
-          o.on("--plugin-clean-sources",
-            "Remove all plugin sources defined so far (including defaults)") do |clean|
-            options[:plugin_sources] = [] if clean
-          end
-
-          o.on("--plugin-source PLUGIN_SOURCE", String,
-               "Add a RubyGems repository source") do |plugin_source|
-            options[:plugin_sources] << plugin_source
-          end
-
-          o.on("--plugin-version PLUGIN_VERSION", String,
-               "Install a specific version of the plugin") do |plugin_version|
-            options[:plugin_version] = plugin_version
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Repair < Base
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin repair [-h]"
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length > 0
-
-          # Attempt to repair installed plugins
-          action(Action.action_repair)
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Root < Vagrant.plugin("2", :command)
-        def self.synopsis
-          "manages plugins: install, uninstall, update, etc."
-        end
-
-        def initialize(argv, env)
-          super
-
-          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
-          @subcommands = Vagrant::Registry.new
-          @subcommands.register(:expunge) do
-            require_relative "expunge"
-            Expunge
-          end
-
-          @subcommands.register(:install) do
-            require_relative "install"
-            Install
-          end
-
-          @subcommands.register(:license) do
-            require_relative "license"
-            License
-          end
-
-          @subcommands.register(:list) do
-            require_relative "list"
-            List
-          end
-
-          @subcommands.register(:repair) do
-            require_relative "repair"
-            Repair
-          end
-
-          @subcommands.register(:update) do
-            require_relative "update"
-            Update
-          end
-
-          @subcommands.register(:uninstall) do
-            require_relative "uninstall"
-            Uninstall
-          end
-        end
-
-        def execute
-          if @main_args.include?("-h") || @main_args.include?("--help")
-            # Print the help for all the sub-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 |o|
-            o.banner = "Usage: vagrant plugin <command> [<args>]"
-            o.separator ""
-            o.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|
-              o.separator "     #{key}"
-            end
-
-            o.separator ""
-            o.separator "For help on any individual command run `vagrant plugin COMMAND -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/plugin/command/uninstall.rb

@@ -1,30 +0,0 @@
-require 'optparse'
-
-require_relative "base"
-
-module VagrantPlugins
-  module CommandPlugin
-    module Command
-      class Uninstall < Base
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant plugin uninstall <name> [<name2> <name3> ...] [-h]"
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-          raise Vagrant::Errors::CLIInvalidUsage, help: opts.help.chomp if argv.length < 1
-
-          # Uninstall the gems
-          argv.each do |gem|
-            action(Action.action_uninstall, plugin_name: gem)
-          end
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end