vagrant-packet 0.1.2 → 0.1.3

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

@@ -1,390 +0,0 @@
-require "delegate"
-require "io/console"
-require "thread"
-
-require "log4r"
-
-require "vagrant/util/platform"
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module UI
-    # Vagrant UIs handle communication with the outside world (typically
-    # through a shell). They must respond to the following methods:
-    #
-    # * `info`
-    # * `warn`
-    # * `error`
-    # * `success`
-    class Interface
-      # Opts can be used to set some options. These options are implementation
-      # specific. See the implementation for more docs.
-      attr_accessor :opts
-
-      # @return [IO] UI input. Defaults to `$stdin`.
-      attr_accessor :stdin
-
-      # @return [IO] UI output. Defaults to `$stdout`.
-      attr_accessor :stdout
-
-      # @return [IO] UI error output. Defaults to `$stderr`.
-      attr_accessor :stderr
-
-      def initialize
-        @logger   = Log4r::Logger.new("vagrant::ui::interface")
-        @opts     = {}
-
-        @stdin  = $stdin
-        @stdout = $stdout
-        @stderr = $stderr
-      end
-
-      def initialize_copy(original)
-        super
-        @opts = original.opts.dup
-      end
-
-      [:ask, :detail, :warn, :error, :info, :output, :success].each do |method|
-        define_method(method) do |message, *opts|
-          # Log normal console messages
-          begin
-            @logger.info { "#{method}: #{message}" }
-          rescue ThreadError
-            # We're being called in a trap-context. Wrap in a thread.
-            Thread.new do
-              @logger.info { "#{method}: #{message}" }
-            end.join(THREAD_MAX_JOIN_TIMEOUT)
-          end
-        end
-      end
-
-      [:clear_line, :report_progress].each do |method|
-        # By default do nothing, these aren't logged
-        define_method(method) { |*args| }
-      end
-
-      # @return [false]
-      def color?
-        return false
-      end
-
-      # For machine-readable output.
-      #
-      # @param [String] type The type of the data
-      # @param [Array] data The data associated with the type
-      def machine(type, *data)
-        @logger.info("Machine: #{type} #{data.inspect}")
-      end
-    end
-
-    # This is a UI implementation that does nothing.
-    class Silent < Interface
-      def ask(*args)
-        super
-
-        # Silent can't do this, obviously.
-        raise Errors::UIExpectsTTY
-      end
-    end
-
-    class MachineReadable < Interface
-      include Util::SafePuts
-
-      def initialize
-        super
-
-        @lock = Mutex.new
-      end
-
-      def ask(*args)
-        super
-
-        # Machine-readable can't ask for input
-        raise Errors::UIExpectsTTY
-      end
-
-      [:detail, :warn, :error, :info, :output, :success].each do |method|
-        define_method(method) do |message, *args, **opts|
-          machine("ui", method.to_s, message, *args, **opts)
-        end
-      end
-
-      def machine(type, *data)
-        opts = {}
-        opts = data.pop if data.last.kind_of?(Hash)
-
-        target = opts[:target] || ""
-
-        # Prepare the data by replacing characters that aren't outputted
-        data.each_index do |i|
-          data[i] = data[i].to_s.dup
-          data[i].gsub!(",", "%!(VAGRANT_COMMA)")
-          data[i].gsub!("\n", "\\n")
-          data[i].gsub!("\r", "\\r")
-        end
-
-        # Avoid locks in a trap context introduced from Ruby 2.0
-        Thread.new do
-          @lock.synchronize do
-            safe_puts("#{Time.now.utc.to_i},#{target},#{type},#{data.join(",")}")
-          end
-        end.join(THREAD_MAX_JOIN_TIMEOUT)
-      end
-    end
-
-    # This is a UI implementation that outputs the text as is. It
-    # doesn't add any color.
-    class Basic < Interface
-      include Util::SafePuts
-
-      def initialize
-        super
-
-        @lock = Mutex.new
-      end
-
-      # Use some light meta-programming to create the various methods to
-      # output text to the UI. These all delegate the real functionality
-      # to `say`.
-      [:detail, :info, :warn, :error, :output, :success].each do |method|
-        class_eval <<-CODE
-          def #{method}(message, *args)
-            super(message)
-            say(#{method.inspect}, message, *args)
-          end
-        CODE
-      end
-
-      def ask(message, opts=nil)
-        super(message)
-
-        # We can't ask questions when the output isn't a TTY.
-        raise Errors::UIExpectsTTY if !@stdin.tty? && !Vagrant::Util::Platform.windows?
-
-        # Setup the options so that the new line is suppressed
-        opts ||= {}
-        opts[:echo]     = true  if !opts.key?(:echo)
-        opts[:new_line] = false if !opts.key?(:new_line)
-        opts[:prefix]   = false if !opts.key?(:prefix)
-
-        # Output the data
-        say(:info, message, opts)
-
-        input = nil
-        if opts[:echo] || !@stdin.respond_to?(:noecho)
-          input = @stdin.gets
-        else
-          begin
-            input = @stdin.noecho(&:gets)
-
-            # Output a newline because without echo, the newline isn't
-            # echoed either.
-            say(:info, "\n", opts)
-          rescue Errno::EBADF
-            # This means that stdin doesn't support echoless input.
-            say(:info, "\n#{I18n.t("vagrant.stdin_cant_hide_input")}\n ", opts)
-
-            # Ask again, with echo enabled
-            input = ask(message, opts.merge(echo: true))
-          end
-        end
-
-        # Get the results and chomp off the newline. We do a logical OR
-        # here because `gets` can return a nil, for example in the case
-        # that ctrl-D is pressed on the input.
-        (input || "").chomp
-      end
-
-      # This is used to output progress reports to the UI.
-      # Send this method progress/total and it will output it
-      # to the UI. Send `clear_line` to clear the line to show
-      # a continuous progress meter.
-      def report_progress(progress, total, show_parts=true)
-        if total && total > 0
-          percent = (progress.to_f / total.to_f) * 100
-          line    = "Progress: #{percent.to_i}%"
-          line   << " (#{progress} / #{total})" if show_parts
-        else
-          line    = "Progress: #{progress}"
-        end
-
-        info(line, new_line: false)
-      end
-
-      def clear_line
-        # See: https://en.wikipedia.org/wiki/ANSI_escape_code
-        reset = "\r\033[K"
-
-        info(reset, new_line: false)
-      end
-
-      # This method handles actually outputting a message of a given type
-      # to the console.
-      def say(type, message, **opts)
-        defaults = { new_line: true, prefix: true }
-        opts     = defaults.merge(@opts).merge(opts)
-
-        # Don't output if we're hiding details
-        return if type == :detail && opts[:hide_detail]
-
-        # Determine whether we're expecting to output our
-        # own new line or not.
-        printer = opts[:new_line] ? :puts : :print
-
-        # Determine the proper IO channel to send this message
-        # to based on the type of the message
-        channel = type == :error || opts[:channel] == :error ? @stderr : @stdout
-
-        # Output! We wrap this in a lock so that it safely outputs only
-        # one line at a time. We wrap this in a thread because as of Ruby 2.0
-        # we can't acquire locks in a trap context (ctrl-c), so we have to
-        # do this.
-        Thread.new do
-          @lock.synchronize do
-            safe_puts(format_message(type, message, **opts),
-                      io: channel, printer: printer)
-          end
-        end.join(THREAD_MAX_JOIN_TIMEOUT)
-      end
-
-      def format_message(type, message, **opts)
-        Util::CredentialScrubber.desensitize(message)
-      end
-    end
-
-    # Prefixed wraps an existing UI and adds a prefix to it.
-    class Prefixed < Interface
-      # The prefix for `output` messages.
-      OUTPUT_PREFIX = "==> "
-
-      def initialize(ui, prefix)
-        super()
-
-        @prefix = prefix
-        @ui     = ui
-      end
-
-      def initialize_copy(original)
-        super
-        @ui = original.instance_variable_get(:@ui).dup
-      end
-
-      # Use some light meta-programming to create the various methods to
-      # output text to the UI. These all delegate the real functionality
-      # to `say`.
-      [:ask, :detail, :info, :warn, :error, :output, :success].each do |method|
-        class_eval <<-CODE
-          def #{method}(message, *args, **opts)
-            super(message)
-            if !@ui.opts.key?(:bold) && !opts.key?(:bold)
-              opts[:bold] = #{method.inspect} != :detail && \
-                #{method.inspect} != :ask
-            end
-            if !opts.key?(:target)
-              opts[:target] = @prefix
-            end
-            @ui.#{method}(format_message(#{method.inspect}, message, **opts), *args, **opts)
-          end
-        CODE
-      end
-
-      [:clear_line, :report_progress].each do |method|
-        # By default do nothing, these aren't formatted
-        define_method(method) { |*args| @ui.send(method, *args) }
-      end
-
-      # For machine-readable output, set the prefix in the
-      # options hash and continue it on.
-      def machine(type, *data)
-        opts = {}
-        opts = data.pop if data.last.is_a?(Hash)
-        opts[:target] = @prefix
-        data << opts
-        @ui.machine(type, *data)
-      end
-
-      # Return the parent's opts.
-      #
-      # @return [Hash]
-      def opts
-        @ui.opts
-      end
-
-      def format_message(type, message, **opts)
-        opts = self.opts.merge(opts)
-
-        prefix = ""
-        if !opts.key?(:prefix) || opts[:prefix]
-          prefix = OUTPUT_PREFIX
-          prefix = " " * OUTPUT_PREFIX.length if \
-            type == :detail || type == :ask || opts[:prefix_spaces]
-        end
-
-        message = Util::CredentialScrubber.desensitize(message)
-
-        # Fast-path if there is no prefix
-        return message if prefix.empty?
-
-        target = @prefix
-        target = opts[:target] if opts.key?(:target)
-        target = "#{target}:" if target != ""
-
-        # Get the lines. The first default is because if the message
-        # is an empty string, then we want to still use the empty string.
-        lines = [message]
-        lines = message.split("\n") if message != ""
-
-        # Otherwise, make sure to prefix every line properly
-        lines.map do |line|
-          "#{prefix}#{target} #{line}"
-        end.join("\n")
-      end
-    end
-
-    # This is a UI implementation that outputs color for various types
-    # of messages. This should only be used with a TTY that supports color,
-    # but is up to the user of the class to verify this is the case.
-    class Colored < Basic
-      # Terminal colors
-      COLORS = {
-        red:     31,
-        green:   32,
-        yellow:  33,
-        blue:    34,
-        magenta: 35,
-        cyan:    36,
-        white:   37,
-      }
-
-      # @return [true]
-      def color?
-        return true
-      end
-
-      # This is called by `say` to format the message for output.
-      def format_message(type, message, **opts)
-        # Get the format of the message before adding color.
-        message = super
-
-        opts = @opts.merge(opts)
-
-        # Special case some colors for certain message types
-        opts[:color] = :red if type == :error
-        opts[:color] = :green if type == :success
-        opts[:color] = :yellow if type == :warn
-
-        # If it is a detail, it is not bold. Every other message type
-        # is bolded.
-        bold  = !!opts[:bold]
-        colorseq = "#{bold ? 1 : 0 }"
-        if opts[:color] && opts[:color] != :default
-          color = COLORS[opts[:color]]
-          colorseq += ";#{color}"
-        end
-
-        # Color the message and make sure to reset the color at the end
-        "\033[#{colorseq}m#{message}\033[0m"
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Vagrant
-  module Util
-    module ANSIEscapeCodeRemover
-      # Removes ANSI escape code sequences from the text and returns
-      # it.
-      #
-      # This removes all the ANSI escape codes listed here along with
-      # the escape codes for VT100 terminals:
-      #
-      # http://ascii-table.com/ansi-escape-sequences.php
-      def remove_ansi_escape_codes(text)
-        # An array of regular expressions which match various kinds
-        # of escape sequences. I can't think of a better single regular
-        # expression or any faster way to do this.
-        matchers = [/\e\[\d*[ABCD]/,       # Matches things like \e[4D
-                    /\e\[(\d*;)?\d*[HF]/,  # Matches \e[1;2H or \e[H
-                    /\e\[(s|u|2J|K)/,      # Matches \e[s, \e[2J, etc.
-                    /\e\[=\d*[hl]/,        # Matches \e[=24h
-                    /\e\[\?[1-9][hl]/,     # Matches \e[?2h
-                    /\e\[20[hl]/,          # Matches \e[20l]
-                    /\e[DME78H]/,          # Matches \eD, \eH, etc.
-                    /\e\[[0-2]?[JK]/,      # Matches \e[0J, \e[K, etc.
-                    ]
-
-        # Take each matcher and replace it with emptiness.
-        matchers.each do |matcher|
-          text.gsub!(matcher, "")
-        end
-
-        text
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-module Vagrant
-  module Util
-    # Utility class which allows blocks of code to be marked as "busy"
-    # with a specified interrupt handler. During busy areas of code, it
-    # is often undesirable for SIGINTs to immediately kill the application.
-    # This class is a helper to cleanly register callbacks to handle this
-    # situation.
-    class Busy
-      @@registered = []
-      @@mutex = Mutex.new
-
-      class << self
-        # Mark a given block of code as a "busy" block of code, which will
-        # register a SIGINT handler for the duration of the block. When a
-        # SIGINT occurs, the `sig_callback` proc will be called. It is up
-        # to the callback to behave properly and exit the application.
-        def busy(sig_callback)
-          register(sig_callback)
-          return yield
-        ensure
-          unregister(sig_callback)
-        end
-
-        # Registers a SIGINT handler. This typically is called from {busy}.
-        # Callbacks are only registered once, so calling this multiple times
-        # with the same callback has no consequence.
-        def register(sig_callback)
-          @@mutex.synchronize do
-            registered << sig_callback
-            registered.uniq!
-
-            # Register the handler if this is our first callback.
-            Signal.trap("INT") { fire_callbacks } if registered.length == 1
-          end
-        end
-
-        # Unregisters a SIGINT handler.
-        def unregister(sig_callback)
-          @@mutex.synchronize do
-            registered.delete(sig_callback)
-
-            # Remove the signal trap if no more registered callbacks exist
-            Signal.trap("INT", "DEFAULT") if registered.empty?
-          end
-        end
-
-        # Fires all the registered callbacks.
-        def fire_callbacks
-          registered.reverse.each { |r| r.call }
-        end
-
-        # Helper method to get access to the class variable. This is mostly
-        # exposed for tests. This shouldn't be mucked with directly, since it's
-        # structure may change at any time.
-        def registered; @@registered; end
-      end
-    end
-  end
-end

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

@@ -1,183 +0,0 @@
-require "log4r"
-require "singleton"
-
-module Vagrant
-  module Util
-    class CheckpointClient
-
-      include Singleton
-
-      # Maximum number of seconds to wait for check to complete
-      CHECKPOINT_TIMEOUT = 10
-
-      # @return [Log4r::Logger]
-      attr_reader :logger
-
-      # @return [Boolean]
-      attr_reader :enabled
-
-      # @return [Hash]
-      attr_reader :files
-
-      # @return [Vagrant::Environment]
-      attr_reader :env
-
-      def initialize
-        @logger = Log4r::Logger.new("vagrant::checkpoint_client")
-        @enabled = false
-      end
-
-      # Setup will attempt to load the checkpoint library and define
-      # required paths
-      #
-      # @param [Vagrant::Environment] env
-      # @return [self]
-      def setup(env)
-        begin
-          require "checkpoint"
-          @enabled = true
-        rescue LoadError
-          @logger.warn("checkpoint library not found. disabling.")
-        end
-        if ENV["VAGRANT_CHECKPOINT_DISABLE"]
-          @logger.debug("checkpoint disabled via explicit user request")
-          @enabled = false
-        end
-        @files = {
-          signature: env.data_dir.join("checkpoint_signature"),
-          cache: env.data_dir.join("checkpoint_cache")
-        }
-        @checkpoint_thread = nil
-        @env = env
-        self
-      end
-
-      # Check has completed
-      def complete?
-        !@checkpoint_thread.nil? && !@checkpoint_thread.alive?
-      end
-
-      # Result of check
-      #
-      # @return [Hash, nil]
-      def result
-        if !enabled || @checkpoint_thread.nil?
-          nil
-        elsif !defined?(@result)
-          @checkpoint_thread.join(CHECKPOINT_TIMEOUT)
-          @result = @checkpoint_thread[:result]
-        else
-          @result
-        end
-      end
-
-      # Run check
-      #
-      # @return [self]
-      def check
-        if enabled && @checkpoint_thread.nil?
-          logger.debug("starting plugin check")
-          @checkpoint_thread = Thread.new do
-            Thread.current.abort_on_exception = false
-            if Thread.current.respond_to?(:report_on_exception=)
-              Thread.current.report_on_exception = false
-            end
-            begin
-              Thread.current[:result] = Checkpoint.check(
-                product: "vagrant",
-                version: VERSION,
-                signature_file: files[:signature],
-                cache_file: files[:cache]
-              )
-              if !Thread.current[:result].is_a?(Hash)
-                Thread.current[:result] = nil
-              end
-              logger.debug("plugin check complete")
-            rescue => e
-              logger.debug("plugin check failure - #{e}")
-            end
-          end
-        end
-        self
-      end
-
-      # Display any alerts or version update information
-      #
-      # @return [boolean] true if displayed, false if not
-      def display
-        if !defined?(@displayed)
-          if !complete?
-            @logger.debug("waiting for checkpoint to complete...")
-          end
-          # Don't display if information is cached
-          if result && !result["cached"]
-            version_check
-            alerts_check
-          else
-            @logger.debug("no information received from checkpoint")
-          end
-          @displayed = true
-        else
-          false
-        end
-      end
-
-      def alerts_check
-        if result["alerts"] && !result["alerts"].empty?
-          result["alerts"].group_by{|a| a["level"]}.each_pair do |_, alerts|
-            alerts.each do |alert|
-              date = nil
-              begin
-                date = Time.at(alert["date"])
-              rescue
-                date = Time.now
-              end
-              output = I18n.t("vagrant.alert",
-                message: alert["message"],
-                date: date,
-                url: alert["url"]
-              )
-              case alert["level"]
-              when "info"
-                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
-                alert_ui.info(output)
-              when "warn"
-                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant-warning")
-                alert_ui.warn(output)
-              when "critical"
-                alert_ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant-alert")
-                alert_ui.error(output)
-              end
-            end
-            env.ui.info("")
-          end
-        else
-          @logger.debug("no alert notifications to display")
-        end
-      end
-
-      def version_check
-        latest_version = Gem::Version.new(result["current_version"])
-        installed_version = Gem::Version.new(VERSION)
-        ui = Vagrant::UI::Prefixed.new(env.ui, "vagrant")
-        if latest_version > installed_version
-          @logger.info("new version of Vagrant available - #{latest_version}")
-          ui.info(I18n.t("vagrant.version_upgrade_available", latest_version: latest_version, installed_version: installed_version))
-          env.ui.info("")
-        else
-          @logger.debug("vagrant is currently up to date")
-        end
-      end
-
-      # @private
-      # Reset the cached values for platform. This is not considered a public
-      # API and should only be used for testing.
-      def reset!
-        logger = @logger
-        instance_variables.each(&method(:remove_instance_variable))
-        @logger = logger
-        @enabled = false
-      end
-    end
-  end
-end