bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/util/connection.rb

@@ -1,74 +0,0 @@
-require 'puppet'
-
-module Puppet::Util
-  module Connection
-    # The logic for server and port is kind of gross. In summary:
-    # IF an endpoint-specific setting is requested AND that setting has been set by the user
-    #    Use that setting.
-    #         The defaults for these settings are the "normal" server/masterport settings, so
-    #         when they are unset we instead want to "fall back" to the failover-selected
-    #         host/port pair.
-    # ELSE IF we have a failover-selected host/port
-    #    Use what the failover logic came up with
-    # ELSE IF the server_list setting is in use
-    #    Use the first entry - failover hasn't happened yet, but that
-    #    setting is still authoritative
-    # ELSE
-    #    Go for the legacy server/masterport settings, and hope for the best
-
-    # Determines which server to use based on the specified setting, taking into
-    # account HA fallback from server_list.
-    # @param [Symbol] setting The preferred server setting to use
-    # @return [String] the name of the server for use in the request
-    def self.determine_server(setting)
-      if setting && setting != :server && Puppet.settings.set_by_config?(setting)
-        Puppet[setting]
-      else
-        server = Puppet.lookup(:server) do
-          if primary_server = Puppet.settings[:server_list][0]
-            Puppet.debug "Dynamically-bound server lookup failed; using first entry"
-            primary_server[0]
-          else
-            setting ||= :server
-            Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
-            Puppet.settings[setting]
-          end
-        end
-        server
-      end
-    end
-
-    # Determines which port to use based on the specified setting, taking into
-    # account HA fallback from server_list.
-    # For port there's a little bit of an extra snag: setting a specific
-    # server setting and relying on the default port for that server is
-    # common, so we also want to check if the assocaited SERVER setting
-    # has been set by the user. If either of those are set we ignore the
-    # failover-selected port.
-    # @param [Symbol] port_setting The preferred port setting to use
-    # @param [Symbol] server_setting The server setting assoicated with this route.
-    # @return [String] the port to use for use in the request
-    def self.determine_port(port_setting, server_setting)
-      if (port_setting && port_setting != :masterport && Puppet.settings.set_by_config?(port_setting)) ||
-         (server_setting && server_setting != :server && Puppet.settings.set_by_config?(server_setting))
-        Puppet.settings[port_setting].to_i
-      else
-        port = Puppet.lookup(:serverport) do
-          if primary_server = Puppet.settings[:server_list][0]
-            Puppet.debug "Dynamically-bound port lookup failed; using first entry"
-
-            # Port might not be set, so we want to fallback in that
-            # case. We know we don't need to use `setting` here, since
-            # the default value of every port setting is `masterport`
-            (primary_server[1] || Puppet.settings[:masterport])
-          else
-            port_setting ||= :masterport
-            Puppet.debug "Dynamically-bound port lookup failed; falling back to #{port_setting} setting"
-            Puppet.settings[port_setting]
-          end
-        end
-        port.to_i
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/constant_inflector.rb

@@ -1,24 +0,0 @@
-# Created on 2008-02-12
-# Copyright Luke Kanies
-
-# NOTE: I think it might be worth considering moving these methods directly into Puppet::Util.
-
-# A common module for converting between constants and
-# file names.
-
-
-module Puppet
-  module Util
-    module ConstantInflector
-      def file2constant(file)
-        file.split("/").collect { |name| name.capitalize }.join("::").gsub(/_+(.)/) { |term| $1.capitalize }
-      end
-      module_function :file2constant
-
-      def constant2file(constant)
-        constant.to_s.gsub(/([a-z])([A-Z])/) { |term| $1 + "_#{$2}" }.gsub("::", "/").downcase
-      end
-      module_function :constant2file
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/diff.rb

@@ -1,79 +0,0 @@
-require 'tempfile'
-
-# Provide a diff between two strings.
-module Puppet::Util::Diff
-  include Puppet::Util::Execution
-  require 'tempfile'
-
-  def diff(old, new)
-    return '' unless diff_cmd = Puppet[:diff] and diff_cmd != ""
-
-    command = [diff_cmd]
-    if args = Puppet[:diff_args] and args != ""
-      args.split(' ').each do|arg|
-        command << arg
-      end
-    end
-    command << old << new
-    Puppet::Util::Execution.execute(command, :failonfail => false, :combine => false)
-  end
-
-  module_function :diff
-
-  # return diff string of two input strings
-  # format defaults to unified
-  # context defaults to 3 lines
-  def lcs_diff(data_old, data_new, format=:unified, context_lines=3)
-    unless Puppet.features.diff?
-      Puppet.warning _("Cannot provide diff without the diff/lcs Ruby library")
-      return ""
-    end
-    data_old = data_old.split(/\n/).map! { |e| e.chomp }
-    data_new = data_new.split(/\n/).map! { |e| e.chomp }
-
-    output = ""
-
-    diffs = ::Diff::LCS.diff(data_old, data_new)
-    return output if diffs.empty?
-
-    oldhunk = hunk = nil
-    file_length_difference = 0
-
-    diffs.each do |piece|
-      begin
-
-        hunk = ::Diff::LCS::Hunk.new(
-          data_old, data_new, piece,
-            context_lines,
-
-            file_length_difference)
-        file_length_difference = hunk.file_length_difference
-      next unless oldhunk
-      # Hunks may overlap, which is why we need to be careful when our
-      # diff includes lines of context. Otherwise, we might print
-      # redundant lines.
-      if (context_lines > 0) and hunk.overlaps?(oldhunk)
-        hunk.unshift(oldhunk)
-      else
-        output << oldhunk.diff(format)
-      end
-      ensure
-        oldhunk = hunk
-        output << "\n"
-      end
-    end
-
-    # Handle the last remaining hunk
-    output << oldhunk.diff(format) << "\n"
-  end
-
-  def string_file_diff(path, string)
-    tempfile = Tempfile.new("puppet-diffing")
-    tempfile.open
-    tempfile.print string
-    tempfile.close
-    notice "\n" + diff(path, tempfile.path)
-    tempfile.delete
-  end
-end
-

data/vendored/puppet/lib/puppet/util/docs.rb

@@ -1,128 +0,0 @@
-# Some simple methods for helping manage automatic documentation generation.
-module Puppet::Util::Docs
-  # Specify the actual doc string.
-  def desc(str)
-    @doc = str
-  end
-
-  # Add a new autodoc block.  We have to define these as class methods,
-  # rather than just sticking them in a hash, because otherwise they're
-  # too difficult to do inheritance with.
-  def dochook(name, &block)
-    method = "dochook_#{name}"
-
-    meta_def method, &block
-  end
-
-  attr_writer :doc
-
-  # Generate the full doc string.
-  def doc
-    extra = methods.find_all { |m| m.to_s =~ /^dochook_.+/ }.sort.collect { |m|
-      self.send(m)
-    }.delete_if {|r| r.nil? }.collect {|r| "* #{r}"}.join("\n")
-
-    if @doc
-      scrub(@doc) + (extra.empty? ? '' : "\n\n#{extra}")
-    else
-      extra
-    end
-  end
-
-  # Build a table
-  def doctable(headers, data)
-    str = "\n\n"
-
-    lengths = []
-    # Figure out the longest field for all columns
-    data.each do |name, values|
-      [name, values].flatten.each_with_index do |value, i|
-        lengths[i] ||= 0
-        lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
-      end
-    end
-
-    # The headers could also be longest
-    headers.each_with_index do |value, i|
-      lengths[i] = value.to_s.length if value.to_s.length > lengths[i]
-    end
-
-    # Add the header names
-    str += headers.zip(lengths).collect { |value, num| pad(value, num) }.join(" | ") + " |" + "\n"
-
-    # And the header row
-    str += lengths.collect { |num| "-" * num }.join(" | ") + " |" + "\n"
-
-    # Now each data row
-    data.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |name, rows|
-      str += [name, rows].flatten.zip(lengths).collect do |value, length|
-        pad(value, length)
-      end.join(" | ") + " |" + "\n"
-    end
-
-    str + "\n"
-  end
-
-  # There is nothing that would ever set this. It gets read in reference/type.rb, but will never have any value but nil.
-  attr_reader :nodoc
-  def nodoc?
-    nodoc
-  end
-
-  # Pad a field with spaces
-  def pad(value, length)
-    value.to_s + (" " * (length - value.to_s.length))
-  end
-
-  HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
-
-  def markdown_header(name, level)
-    "#{HEADER_LEVELS[level]} #{name}\n\n"
-  end
-
-  def markdown_definitionlist(term, definition)
-    lines = scrub(definition).split("\n")
-    str = "#{term}\n: #{lines.shift}\n"
-    lines.each do |line|
-      str << "  " if line =~ /\S/
-      str << "#{line}\n"
-    end
-    str << "\n"
-  end
-
-  # Strip indentation and trailing whitespace from embedded doc fragments.
-  #
-  # Multi-line doc fragments are sometimes indented in order to preserve the
-  # formatting of the code they're embedded in. Since indents are syntactic
-  # elements in Markdown, we need to make sure we remove any indent that was
-  # added solely to preserve surrounding code formatting, but LEAVE any indent
-  # that delineates a Markdown element (code blocks, multi-line bulleted list
-  # items). We can do this by removing the *least common indent* from each line.
-  #
-  # Least common indent is defined as follows:
-  #
-  # * Find the smallest amount of leading space on any line...
-  # * ...excluding the first line (which may have zero indent without affecting
-  #   the common indent)...
-  # * ...and excluding lines that consist solely of whitespace.
-  # * The least common indent may be a zero-length string, if the fragment is
-  #   not indented to match code.
-  # * If there are hard tabs for some dumb reason, we assume they're at least
-  #   consistent within this doc fragment.
-  #
-  # See tests in spec/unit/util/docs_spec.rb for examples.
-  def scrub(text)
-    # One-liners are easy! (One-liners may be buffered with extra newlines.)
-    return text.strip if text.strip !~ /\n/
-    excluding_first_line = text.partition("\n").last
-    indent = excluding_first_line.scan(/^[ \t]*(?=\S)/).min || '' # prevent nil
-    # Clean hanging indent, if any
-    if indent.length > 0
-      text = text.gsub(/^#{indent}/, '')
-    end
-    # Clean trailing space
-    text.lines.map{|line|line.rstrip}.join("\n").rstrip
-  end
-
-  module_function :scrub
-end

data/vendored/puppet/lib/puppet/util/errors.rb

@@ -1,159 +0,0 @@
-# Some helper methods for throwing and populating errors.
-#
-# @api public
-module Puppet::Util::Errors
-  # Throw a Puppet::DevError with the specified message.  Used for unknown or
-  # internal application failures.
-  #
-  # @param msg [String] message used in raised error
-  # @raise [Puppet::DevError] always raised with the supplied message
-  def devfail(msg)
-    self.fail(Puppet::DevError, msg)
-  end
-
-  # Add line and file info to the supplied exception if info is available from
-  # this object, is appropriately populated and the supplied exception supports
-  # it.  When other is supplied, the backtrace will be copied to the error
-  # object and the 'original' will be dropped from the error.
-  #
-  # @param error [Exception] exception that is populated with info
-  # @param other [Exception] original exception, source of backtrace info
-  # @return [Exception] error parameter
-  def adderrorcontext(error, other = nil)
-    error.line ||= self.line if error.respond_to?(:line=) and self.respond_to?(:line) and self.line
-    error.file ||= self.file if error.respond_to?(:file=) and self.respond_to?(:file) and self.file
-    error.original ||= other if error.respond_to?(:original=)
-
-    error.set_backtrace(other.backtrace) if other and other.respond_to?(:backtrace)
-    # It is not meaningful to keep the wrapped exception since its backtrace has already
-    # been adopted by the error. (The instance variable is private for good reasons).
-    error.instance_variable_set(:@original, nil)
-    error
-  end
-
-  # Return a human-readable string of this object's file, line, and pos attributes,
-  # if set.
-  #
-  # @param file [String] the file path for the error (nil or "", for not known)
-  # @param line [String] the line number for the error (nil or "", for not known)
-  # @param column [String] the column number for the error (nil or "",  for not known)
-  # @return [String] description of file, line, and column
-  #
-  def self.error_location(file, line=nil, column=nil)
-    file = nil if (file.is_a?(String) && file.empty?)
-    line = nil if (line.is_a?(String) && line.empty?)
-    column = nil if (column.is_a?(String) && column.empty?)
-    if file and line and column
-      _("(file: %{file}, line: %{line}, column: %{column})") % { file: file, line: line, column: column }
-    elsif file and line
-      _("(file: %{file}, line: %{line})") % { file: file, line: line }
-    elsif line and column
-      _("(line: %{line}, column: %{column})") % { line: line, column: column }
-    elsif line
-      _("(line: %{line})") % { line: line }
-    elsif file
-      _("(file: %{file})") % { file: file }
-    else
-      ''
-    end
-  end
-
-  # Return a human-readable string of this object's file, line, and pos attributes,
-  # with a proceeding space in the output
-  # if set.
-  #
-  # @param file [String] the file path for the error (nil or "", for not known)
-  # @param line [String] the line number for the error (nil or "", for not known)
-  # @param column [String] the column number for the error (nil or "",  for not known)
-  # @return [String] description of file, line, and column
-  #
-  def self.error_location_with_space(file, line=nil, column=nil)
-    error_location_str = error_location(file, line, column)
-    if error_location_str.empty?
-      ''
-    else
-      ' ' + error_location_str
-    end
-  end
-
-  # Return a human-readable string of this object's file and line
-  # where unknown entries are listed as 'unknown'
-  #
-  # @param file [String] the file path for the error (nil or "", for not known)
-  # @param line [String] the line number for the error (nil or "", for not known)
-  # @return [String] description of file, and line
-  def self.error_location_with_unknowns(file, line)
-    file = nil if (file.is_a?(String) && file.empty?)
-    line = nil if (line.is_a?(String) && line.empty?)
-    file = _('unknown') unless file
-    line = _('unknown') unless line
-    error_location(file, line)
-  end
-
-  # Return a human-readable string of this object's file and line attributes,
-  # if set.
-  #
-  # @return [String] description of file and line with a leading space
-  def error_context
-    Puppet::Util::Errors.error_location_with_space(file, line)
-  end
-
-  # Wrap a call in such a way that we always throw the right exception and keep
-  # as much context as possible.
-  #
-  # @param options [Hash<Symbol,Object>] options used to create error
-  # @option options [Class] :type error type to raise, defaults to
-  #   Puppet::DevError
-  # @option options [String] :message message to use in error, default mentions
-  #   the name of this class
-  # @raise [Puppet::Error] re-raised with extra context if the block raises it
-  # @raise [Error] of type options[:type], when the block raises other
-  #   exceptions
-  def exceptwrap(options = {})
-    options[:type] ||= Puppet::DevError
-    begin
-      return yield
-    rescue Puppet::Error => detail
-      raise adderrorcontext(detail)
-    rescue => detail
-      message = options[:message] || _("%{klass} failed with error %{error_type}: %{detail}") % { klass: self.class, error_type: detail.class, detail: detail }
-
-      error = options[:type].new(message)
-      # We can't use self.fail here because it always expects strings,
-      # not exceptions.
-      raise adderrorcontext(error, detail)
-    end
-
-    retval
-  end
-
-  # Throw an error, defaulting to a Puppet::Error.
-  #
-  # @overload fail(message, ..)
-  #   Throw a Puppet::Error with a message concatenated from the given
-  #   arguments.
-  #   @param [String] message error message(s)
-  # @overload fail(error_klass, message, ..)
-  #   Throw an exception of type error_klass with a message concatenated from
-  #   the given arguments.
-  #   @param [Class] type of error
-  #   @param [String] message error message(s)
-  # @overload fail(error_klass, message, ..)
-  #   Throw an exception of type error_klass with a message concatenated from
-  #   the given arguments.
-  #   @param [Class] type of error
-  #   @param [String] message error message(s)
-  #   @param [Exception] original exception, source of backtrace info
-  def fail(*args)
-    if args[0].is_a?(Class)
-      type = args.shift
-    else
-      type = Puppet::Error
-    end
-
-    other = args.count > 1 ? args.pop : nil
-    error = adderrorcontext(type.new(args.join(" ")), other)
-
-    raise error
-  end
-end