bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/network/format_handler.rb

@@ -1,108 +0,0 @@
-require 'yaml'
-require 'puppet/network'
-require 'puppet/network/format'
-
-module Puppet::Network::FormatHandler
-  class FormatError < Puppet::Error; end
-
-  ALL_MEDIA_TYPES = '*/*'.freeze
-
-  @formats = {}
-
-  def self.create(*args, &block)
-    instance = Puppet::Network::Format.new(*args, &block)
-
-    @formats[instance.name] = instance
-    instance
-  end
-
-  def self.create_serialized_formats(name,options = {},&block)
-    ["application/x-#{name}", "application/#{name}", "text/x-#{name}", "text/#{name}"].each { |mime_type|
-      create name, {:mime => mime_type}.update(options), &block
-    }
-  end
-
-  def self.format(name)
-    @formats[name.to_s.downcase.intern]
-  end
-
-  def self.format_for(name)
-    name = format_to_canonical_name(name)
-    format(name)
-  end
-
-  def self.format_by_extension(ext)
-    @formats.each do |name, format|
-      return format if format.extension == ext
-    end
-    nil
-  end
-
-  # Provide a list of all formats.
-  def self.formats
-    @formats.keys
-  end
-
-  # Return a format capable of handling the provided mime type.
-  def self.mime(mimetype)
-    mimetype = mimetype.to_s.downcase
-    @formats.values.find { |format| format.mime == mimetype }
-  end
-
-  # Return a format name given:
-  #  * a format name
-  #  * a mime-type
-  #  * a format instance
-  def self.format_to_canonical_name(format)
-    case format
-    when Puppet::Network::Format
-      out = format
-    when %r{\w+/\w+}
-      out = mime(format)
-    else
-      out = format(format)
-    end
-
-    if out.nil?
-      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % {format: format}
-    end
-
-    out.name
-  end
-
-  # Determine which of the accepted formats should be used given what is supported.
-  #
-  # @param accepted [Array<String, Symbol>] the accepted formats in a form a
-  #   that generally conforms to an HTTP Accept header. Any quality specifiers
-  #   are ignored and instead the formats are simply in strict preference order
-  #   (most preferred is first)
-  # @param supported [Array<Symbol>] the names of the supported formats (the
-  #   most preferred format is first)
-  # @return [Array<Puppet::Network::Format>] the most suitable formats that
-  #   are both accepted and supported
-  # @api private
-  def self.most_suitable_formats_for(accepted, supported)
-    accepted.collect do |format|
-      format.to_s.sub(/;q=.*$/, '')
-    end.collect do |format|
-      if format == ALL_MEDIA_TYPES
-        supported.first
-      else
-        format_to_canonical_name_or_nil(format)
-      end
-    end.compact.find_all do |format|
-      supported.include?(format)
-    end.collect do |format|
-      format_for(format)
-    end
-  end
-
-  # @api private
-  def self.format_to_canonical_name_or_nil(format)
-    format_to_canonical_name(format)
-  rescue ArgumentError
-    nil
-  end
-end
-
-require 'puppet/network/formats'

data/vendored/puppet/lib/puppet/network/format_support.rb

@@ -1,139 +0,0 @@
-require 'puppet/network/format_handler'
-
-# Provides network serialization support when included
-# @api public
-module Puppet::Network::FormatSupport
-  def self.included(klass)
-    klass.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    def convert_from(format, data)
-      get_format(format).intern(self, data)
-    rescue => err
-      #TRANSLATORS "intern" is a function name and should not be translated
-      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
-    end
-
-    def convert_from_multiple(format, data)
-      get_format(format).intern_multiple(self, data)
-    rescue => err
-      #TRANSLATORS "intern_multiple" is a function name and should not be translated
-      raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
-    end
-
-    def render_multiple(format, instances)
-      get_format(format).render_multiple(instances)
-    rescue => err
-      #TRANSLATORS "render_multiple" is a function name and should not be translated
-      raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: err }, err.backtrace
-    end
-
-    def default_format
-      supported_formats[0]
-    end
-
-    def support_format?(name)
-      Puppet::Network::FormatHandler.format(name).supported?(self)
-    end
-
-    def supported_formats
-      result = format_handler.formats.collect do |f|
-        format_handler.format(f)
-      end.find_all do |f|
-        f.supported?(self)
-      end.sort do |a, b|
-        # It's an inverse sort -- higher weight formats go first.
-        b.weight <=> a.weight
-      end
-
-      result = put_preferred_format_first(result).map(&:name)
-
-      Puppet.debug "#{friendly_name} supports formats: #{result.join(' ')}"
-
-      result
-    end
-
-    # @api private
-    def get_format(format_name)
-      format_handler.format_for(format_name)
-    end
-
-    private
-
-    def format_handler
-      Puppet::Network::FormatHandler
-    end
-
-    def friendly_name
-      if self.respond_to? :indirection
-        indirection.name
-      else
-        self
-      end
-    end
-
-    def put_preferred_format_first(list)
-      preferred_format = Puppet.settings[:preferred_serialization_format].to_s
-
-      preferred = list.select { |format|
-        format.mime.end_with?(preferred_format)
-      }
-
-      if preferred.empty?
-        Puppet.debug "Value of 'preferred_serialization_format' (#{preferred_format}) is invalid for #{friendly_name}, using default (#{list.first.name})"
-      else
-        list = preferred + list.reject { |format|
-          format.mime.end_with?(preferred_format)
-        }
-      end
-
-      list
-    end
-  end
-
-  def to_msgpack(*args)
-    to_data_hash.to_msgpack(*args)
-  end
-
-  # @deprecated, use to_json
-  def to_pson(*args)
-    to_data_hash.to_pson(*args)
-  end
-
-  def to_json(*args)
-    Puppet::Util::Json.dump(to_data_hash, *args)
-  end
-
-  def render(format = nil)
-    format ||= self.class.default_format
-
-    self.class.get_format(format).render(self)
-  rescue => err
-    #TRANSLATORS "render" is a function name and should not be translated
-    raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
-  end
-
-  def mime(format = nil)
-    format ||= self.class.default_format
-
-    self.class.get_format(format).mime
-  rescue => err
-    #TRANSLATORS "mime" is a function name and should not be translated
-    raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: err }, err.backtrace
-  end
-
-  def support_format?(name)
-    self.class.support_format?(name)
-  end
-
-  # @comment Document to_data_hash here as it is called as a hook from to_msgpack if it exists
-  # @!method to_data_hash(*args)
-  # @api public
-  # @abstract
-  # This method may be implemented to return a hash object that is used for serializing.
-  # The object returned by this method should contain all the info needed to instantiate it again.
-  # If the method exists it will be called from to_msgpack and other serialization methods.
-  # @return [Hash]
-end
-

data/vendored/puppet/lib/puppet/network/formats.rb

@@ -1,260 +0,0 @@
-require 'puppet/network/format_handler'
-require 'puppet/util/json'
-
-Puppet::Network::FormatHandler.create_serialized_formats(:msgpack, :weight => 20, :mime => "application/x-msgpack", :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
-
-  confine :feature => :msgpack
-
-  def intern(klass, text)
-    data = MessagePack.unpack(text)
-    return data if data.is_a?(klass)
-    klass.from_data_hash(data)
-  end
-
-  def intern_multiple(klass, text)
-    MessagePack.unpack(text).collect do |data|
-      klass.from_data_hash(data)
-    end
-  end
-
-  def render_multiple(instances)
-    instances.to_msgpack
-  end
-end
-
-Puppet::Network::FormatHandler.create_serialized_formats(:yaml) do
-  def allowed_yaml_classes
-    @allowed_yaml_classes ||= [
-      Puppet::Node::Facts,
-      Puppet::Node,
-      Puppet::Transaction::Report,
-      Puppet::Resource,
-      Puppet::Resource::Catalog
-    ]
-  end
-
-  def intern(klass, text)
-    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
-    data_to_instance(klass, data)
-  rescue Puppet::Util::Yaml::YamlLoadError => e
-    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
-  end
-
-  def intern_multiple(klass, text)
-    data = Puppet::Util::Yaml.safe_load(text, allowed_yaml_classes)
-    unless data.respond_to?(:collect)
-      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a collection of instances when calling intern_multiple")
-    end
-
-    data.collect do |datum|
-      data_to_instance(klass, datum)
-    end
-  rescue Puppet::Util::Yaml::YamlLoadError => e
-    raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}: %{message}") % { klass: klass, message: e.message }
-  end
-
-  def data_to_instance(klass, data)
-    return data if data.is_a?(klass)
-
-    unless data.is_a? Hash
-      raise Puppet::Network::FormatHandler::FormatError, _("Serialized YAML did not contain a valid instance of %{klass}") % { klass: klass }
-    end
-
-    klass.from_data_hash(data)
-  end
-
-  def render(instance)
-    instance.to_yaml
-  end
-
-  # Yaml monkey-patches Array, so this works.
-  def render_multiple(instances)
-    instances.to_yaml
-  end
-
-  def supported?(klass)
-    true
-  end
-end
-
-Puppet::Network::FormatHandler.create(:s, :mime => "text/plain", :charset => Encoding::UTF_8, :extension => "txt")
-
-# By default, to_binary is called to render and from_binary called to intern. Note unlike
-# text-based formats (json, yaml, etc), we don't use to_data_hash for binary.
-Puppet::Network::FormatHandler.create(:binary, :mime => "application/octet-stream", :weight => 1,
-                                      :required_methods => [:render_method, :intern_method]) do
-end
-
-# PSON is deprecated
-Puppet::Network::FormatHandler.create_serialized_formats(:pson, :weight => 10, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
-  def intern(klass, text)
-    data_to_instance(klass, PSON.parse(text))
-  end
-
-  def intern_multiple(klass, text)
-    PSON.parse(text).collect do |data|
-      data_to_instance(klass, data)
-    end
-  end
-
-  # PSON monkey-patches Array, so this works.
-  def render_multiple(instances)
-    instances.to_pson
-  end
-
-  # If they pass class information, we want to ignore it.
-  # This is required for compatibility with Puppet 3.x
-  def data_to_instance(klass, data)
-    if data.is_a?(Hash) and d = data['data']
-      data = d
-    end
-    return data if data.is_a?(klass)
-    klass.from_data_hash(data)
-  end
-end
-
-Puppet::Network::FormatHandler.create_serialized_formats(:json, :mime => 'application/json', :charset => Encoding::UTF_8, :weight => 15, :required_methods => [:render_method, :intern_method], :intern_method => :from_data_hash) do
-  def intern(klass, text)
-    data_to_instance(klass, Puppet::Util::Json.load(text))
-  end
-
-  def intern_multiple(klass, text)
-    Puppet::Util::Json.load(text).collect do |data|
-      data_to_instance(klass, data)
-    end
-  end
-
-  def render_multiple(instances)
-    Puppet::Util::Json.dump(instances)
-  end
-
-  # Unlike PSON, we do not need to unwrap the data envelope, because legacy 3.x agents
-  # have never supported JSON
-  def data_to_instance(klass, data)
-    return data if data.is_a?(klass)
-    klass.from_data_hash(data)
-  end
-end
-
-# This is really only ever going to be used for Catalogs.
-Puppet::Network::FormatHandler.create_serialized_formats(:dot, :required_methods => [:render_method])
-
-
-Puppet::Network::FormatHandler.create(:console,
-                                      :mime   => 'text/x-console-text',
-                                      :weight => 0) do
-  def json
-    @json ||= Puppet::Network::FormatHandler.format(:json)
-  end
-
-  def render(datum)
-    return datum if datum.is_a?(String) || datum.is_a?(Numeric)
-
-    # Simple hash to table
-    if datum.is_a?(Hash) && datum.keys.all? { |x| x.is_a?(String) || x.is_a?(Numeric) }
-      output = ''
-      column_a = datum.empty? ? 2 : datum.map{ |k,v| k.to_s.length }.max + 2
-      datum.sort_by { |k,v| k.to_s } .each do |key, value|
-        output << key.to_s.ljust(column_a)
-        output << json.render(value).
-          chomp.gsub(/\n */) { |x| x + (' ' * column_a) }
-        output << "\n"
-      end
-      return output
-    end
-
-    # Print one item per line for arrays
-    if datum.is_a? Array
-      output = ''
-      datum.each do |item|
-        output << item.to_s
-        output << "\n"
-      end
-      return output
-    end
-
-    # ...or pretty-print the inspect outcome.
-    Puppet::Util::Json.dump(datum, :pretty => true, :quirks_mode => true)
-  end
-
-  def render_multiple(data)
-    data.collect(&:render).join("\n")
-  end
-end
-
-Puppet::Network::FormatHandler.create(:rich_data_json, mime: 'application/vnd.puppet.rich+json', charset: Encoding::UTF_8, weight: 30) do
-  def intern(klass, text)
-    Puppet.override({:rich_data => true}) do
-      data_to_instance(klass, Puppet::Util::Json.load(text))
-    end
-  end
-
-  def intern_multiple(klass, text)
-    Puppet.override({:rich_data => true}) do
-      Puppet::Util::Json.load(text).collect do |data|
-        data_to_instance(klass, data)
-      end
-    end
-  end
-
-  def render(instance)
-    Puppet.override({:rich_data => true}) do
-      instance.to_json
-    end
-  end
-
-  def render_multiple(instances)
-    Puppet.override({:rich_data => true}) do
-      Puppet::Util::Json.dump(instances)
-    end
-  end
-
-  def data_to_instance(klass, data)
-    Puppet.override({:rich_data => true}) do
-      return data if data.is_a?(klass)
-      klass.from_data_hash(data)
-    end
-  end
-
-  def supported?(klass)
-    klass == Puppet::Resource::Catalog &&
-      Puppet.lookup(:current_environment).rich_data?
-  end
-end
-
-Puppet::Network::FormatHandler.create_serialized_formats(:rich_data_msgpack, mime: "application/vnd.puppet.rich+msgpack", weight: 35) do
-  confine :feature => :msgpack
-
-  def intern(klass, text)
-    Puppet.override(rich_data: true) do
-      data = MessagePack.unpack(text)
-      return data if data.is_a?(klass)
-      klass.from_data_hash(data)
-    end
-  end
-
-  def intern_multiple(klass, text)
-    Puppet.override(rich_data: true) do
-      MessagePack.unpack(text).collect do |data|
-        klass.from_data_hash(data)
-      end
-    end
-  end
-
-  def render_multiple(instances)
-    Puppet.override(rich_data: true) do
-      instances.to_msgpack
-    end
-  end
-
-  def render(instance)
-    Puppet.override(rich_data: true) do
-      instance.to_msgpack
-    end
-  end
-
-  def supported?(klass)
-    klass == Puppet::Resource::Catalog &&
-      Puppet.lookup(:current_environment).rich_data?
-  end
-end