bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/reference/report.rb

@@ -1,20 +0,0 @@
-require 'puppet/reports'
-
-report = Puppet::Util::Reference.newreference :report, :doc => "All available transaction reports" do
-  Puppet::Reports.reportdocs
-end
-
-report.header = "
-Puppet can generate a report after applying a catalog. This report includes
-events, log messages, resource statuses, and metrics and metadata about the run.
-Puppet agent sends its report to a Puppet master server, and Puppet apply
-processes its own reports.
-
-Puppet master and Puppet apply will handle every report with a set of report
-processors, configurable with the `reports` setting in puppet.conf. This page
-documents the built-in report processors.
-
-See [About Reporting](https://docs.puppetlabs.com/puppet/latest/reference/reporting_about.html)
-for more details.
-
-"

data/vendored/puppet/lib/puppet/reference/type.rb

@@ -1,113 +0,0 @@
-Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
-  types = {}
-  Puppet::Type.loadall
-
-  Puppet::Type.eachtype { |type|
-    next if type.name == :component
-    next if type.name == :whit
-    types[type.name] = type
-  }
-
-  str = %{
-
-## Resource Types
-
-- The *namevar* is the parameter used to uniquely identify a type instance.
-  This is the parameter that gets assigned when a string is provided before
-  the colon in a type declaration.  In general, only developers will need to
-  worry about which parameter is the `namevar`.
-
-  In the following code:
-
-      file { "/etc/passwd":
-        owner => "root",
-        group => "root",
-        mode  => "0644"
-      }
-
-  `/etc/passwd` is considered the title of the file object (used for things like
-  dependency handling), and because `path` is the namevar for `file`, that
-  string is assigned to the `path` parameter.
-
-- *Parameters* determine the specific configuration of the instance.  They either
-  directly modify the system (internally, these are called properties) or they affect
-  how the instance behaves (e.g., adding a search path for `exec` instances or determining recursion on `file` instances).
-
-- *Providers* provide low-level functionality for a given resource type.  This is
-  usually in the form of calling out to external commands.
-
-  When required binaries are specified for providers, fully qualified paths
-  indicate that the binary must exist at that specific path and unqualified
-  binaries indicate that Puppet will search for the binary using the shell
-  path.
-
-- *Features* are abilities that some providers might not support.  You can use the list
-  of supported features to determine how a given provider can be used.
-
-  Resource types define features they can use, and providers can be tested to see
-  which features they provide.
-
-  }
-
-  types.sort { |a,b|
-    a.to_s <=> b.to_s
-  }.each { |name,type|
-
-    str << "
-
-----------------
-
-"
-
-    str << markdown_header(name, 3)
-    str << scrub(type.doc) + "\n\n"
-
-    # Handle the feature docs.
-    if featuredocs = type.featuredocs
-      str << markdown_header("Features", 4)
-      str << featuredocs
-    end
-
-    docs = {}
-    type.validproperties.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.reject { |sname|
-      property = type.propertybyname(sname)
-      property.nodoc
-    }.each { |sname|
-      property = type.propertybyname(sname)
-
-      raise _("Could not retrieve property %{sname} on type %{type_name}") % { sname: sname, type_name: type.name } unless property
-
-      unless doc = property.doc
-        $stderr.puts _("No docs for %{type}[%{sname}]") % { type: type, sname: sname }
-        next
-      end
-      doc = doc.dup
-      tmp = doc
-      tmp = scrub(tmp)
-
-      docs[sname]  = tmp
-    }
-
-    str << markdown_header("Parameters", 4) + "\n"
-    type.parameters.sort { |a,b|
-      a.to_s <=> b.to_s
-    }.each { |type_name, param|
-      docs[type_name] = scrub(type.paramdoc(type_name))
-    }
-
-    additional_key_attributes = type.key_attributes - [:name]
-    docs.sort { |a, b|
-      a[0].to_s <=> b[0].to_s
-    }.each { |type_name, doc|
-      if additional_key_attributes.include?(type_name)
-        doc = "(**Namevar:** If omitted, this parameter's value defaults to the resource's title.)\n\n" + doc
-      end
-      str << markdown_definitionlist(type_name, doc)
-    }
-    str << "\n"
-  }
-
-  str
-end

data/vendored/puppet/lib/puppet/relationship.rb

@@ -1,89 +0,0 @@
-# subscriptions are permanent associations determining how different
-# objects react to an event
-
-# This is Puppet's class for modeling edges in its configuration graph.
-# It used to be a subclass of GRATR::Edge, but that class has weird hash
-# overrides that dramatically slow down the graphing.
-class Puppet::Relationship
-
-  # FormatSupport for serialization methods
-  include Puppet::Network::FormatSupport
-  include Puppet::Util::PsychSupport
-
-  attr_accessor :source, :target, :callback
-
-  attr_reader :event
-
-  def self.from_data_hash(data)
-    source = data['source']
-    target = data['target']
-
-    args = {}
-    if event = data["event"]
-      args[:event] = :"#{event}"
-    end
-    if callback = data["callback"]
-      args[:callback] = :"#{callback}"
-    end
-
-    new(source, target, args)
-  end
-
-  def event=(event)
-    #TRANSLATORS 'NONE' should not be translated
-    raise ArgumentError, _("You must pass a callback for non-NONE events") if event != :NONE and ! callback
-    @event = event
-  end
-
-  def initialize(source, target, options = {})
-    @source, @target = source, target
-
-    options = (options || {}).inject({}) { |h,a| h[a[0].to_sym] = a[1]; h }
-    [:callback, :event].each do |option|
-      if value = options[option]
-        send(option.to_s + "=", value)
-      end
-    end
-  end
-
-  # Does the passed event match our event?  This is where the meaning
-  # of :NONE comes from.
-  def match?(event)
-    if self.event.nil? or event == :NONE or self.event == :NONE
-      return false
-    elsif self.event == :ALL_EVENTS or event == self.event
-      return true
-    else
-      return false
-    end
-  end
-
-  def label
-    result = {}
-    result[:callback] = callback if callback
-    result[:event] = event if event
-    result
-  end
-
-  def ref
-    "#{source} => #{target}"
-  end
-
-  def inspect
-    "{ #{source} => #{target} }"
-  end
-
-  def to_data_hash
-    data = {
-      'source' => source.to_s,
-      'target' => target.to_s
-    }
-    data['event'] = event.to_s unless event.nil?
-    data['callback'] = callback.to_s unless callback.nil?
-    data
-  end
-
-  def to_s
-    ref
-  end
-end

data/vendored/puppet/lib/puppet/reports.rb

@@ -1,93 +0,0 @@
-require 'puppet/util/instance_loader'
-
-# This class is an implementation of a simple mechanism for loading and returning reports.
-# The intent is that a user registers a report by calling {register_report} and providing a code
-# block that performs setup, and defines a method called `process`. The setup, and the `process` method
-# are called in the context where `self` is an instance of {Puppet::Transaction::Report} which provides the actual
-# data for the report via its methods.
-#
-# @example Minimal scaffolding for a report...
-#   Puppet::Reports::.register_report(:myreport) do
-#     # do setup here
-#     def process
-#       if self.status == 'failed'
-#         msg = "failed puppet run for #{self.host} #{self.status}"
-#         . . .
-#       else
-#         . . .
-#       end
-#     end
-#   end
-#
-# Required configuration:
-# --
-# * A .rb file that defines a new report should be placed in the master's directory `lib/puppet/reports`
-# * The `puppet.conf` file must have `report = true` in the `[agent]` section
-#
-# @see Puppet::Transaction::Report
-# @api public
-#
-class Puppet::Reports
-  extend Puppet::Util::ClassGen
-  extend Puppet::Util::InstanceLoader
-
-  # Set up autoloading and retrieving of reports.
-  instance_load :report, 'puppet/reports'
-
-  class << self
-    # @api private
-    attr_reader :hooks
-  end
-
-  # Adds a new report type.
-  # The block should contain setup, and define a method with the name `process`. The `process` method is
-  # called when the report is executed; the `process` method has access to report data via methods available
-  # in its context where `self` is an instance of {Puppet::Transaction::Report}.
-  #
-  # For an example, see the overview of this class.
-  #
-  # @param name [Symbol] the name of the report (do not use whitespace in the name).
-  # @param options [Hash] a hash of options
-  # @option options [Boolean] :useyaml whether yaml should be used or not
-  # @todo Uncertain what the options :useyaml really does; "whether yaml should be used or not", used where/how?
-  #
-  def self.register_report(name, options = {}, &block)
-    name = name.intern
-
-    mod = genmodule(name,
-                    :extend    => Puppet::Util::Docs,
-                    :hash      => instance_hash(:report),
-                    :overwrite => true,
-                    :block     => block)
-
-    mod.useyaml = true if options[:useyaml]
-
-    mod.send(:define_method, :report_name) do
-      name
-    end
-  end
-
-  # Collects the docs for all reports.
-  # @api private
-  def self.reportdocs
-    docs = ""
-
-    # Use this method so they all get loaded
-    instance_loader(:report).loadall
-    loaded_instances(:report).sort { |a,b| a.to_s <=> b.to_s }.each do |name|
-      mod = self.report(name)
-      docs << "#{name}\n#{"-" * name.to_s.length}\n"
-
-      docs << Puppet::Util::Docs.scrub(mod.doc) << "\n\n"
-    end
-
-    docs
-  end
-
-  # Lists each of the reports.
-  # @api private
-  def self.reports
-    instance_loader(:report).loadall
-    loaded_instances(:report)
-  end
-end

data/vendored/puppet/lib/puppet/reports/http.rb

@@ -1,37 +0,0 @@
-require 'puppet'
-require 'puppet/network/http_pool'
-require 'uri'
-
-Puppet::Reports.register_report(:http) do
-
-  desc <<-DESC
-    Send reports via HTTP or HTTPS. This report processor submits reports as
-    POST requests to the address in the `reporturl` setting. When a HTTPS URL
-    is used, the remote server must present a certificate issued by the Puppet
-    CA or the connection will fail validation. The body of each POST request
-    is the YAML dump of a Puppet::Transaction::Report object, and the
-    Content-Type is set as `application/x-yaml`.
-  DESC
-
-  def process
-    url = URI.parse(Puppet[:reporturl])
-    headers = { "Content-Type" => "application/x-yaml" }
-    # This metric_id option is silently ignored by Puppet's http client
-    # (Puppet::Network::HTTP) but is used by Puppet Server's http client
-    # (Puppet::Server::HttpClient) to track metrics on the request made to the
-    # `reporturl` to store a report.
-    options = { :metric_id => [:puppet, :report, :http] }
-    if url.user && url.password
-      options[:basic_auth] = {
-        :user => url.user,
-        :password => url.password
-      }
-    end
-    use_ssl = url.scheme == 'https'
-    conn = Puppet::Network::HttpPool.http_instance(url.host, url.port, use_ssl)
-    response = conn.post(url.path, self.to_yaml, headers, options)
-    unless response.kind_of?(Net::HTTPSuccess)
-      Puppet.err _("Unable to submit report to %{url} [%{code}] %{message}") % { url: Puppet[:reporturl].to_s, code: response.code, message: response.msg }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/reports/log.rb

@@ -1,14 +0,0 @@
-require 'puppet/reports'
-
-Puppet::Reports.register_report(:log) do
-  desc "Send all received logs to the local log destinations.  Usually
-    the log destination is syslog."
-
-  def process
-    self.logs.each do |log|
-      log.source = "//#{self.host}/#{log.source}"
-      Puppet::Util::Log.newmessage(log)
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/reports/store.rb

@@ -1,68 +0,0 @@
-require 'puppet'
-require 'fileutils'
-require 'puppet/util'
-
-SEPARATOR = [Regexp.escape(File::SEPARATOR.to_s), Regexp.escape(File::ALT_SEPARATOR.to_s)].join
-
-Puppet::Reports.register_report(:store) do
-  desc "Store the yaml report on disk.  Each host sends its report as a YAML dump
-    and this just stores the file on disk, in the `reportdir` directory.
-
-    These files collect quickly -- one every half hour -- so it is a good idea
-    to perform some maintenance on them if you use this report (it's the only
-    default report)."
-
-  def process
-    validate_host(host)
-
-    dir = File.join(Puppet[:reportdir], host)
-
-    if ! Puppet::FileSystem.exist?(dir)
-      FileUtils.mkdir_p(dir)
-      FileUtils.chmod_R(0750, dir)
-    end
-
-    # Now store the report.
-    now = Time.now.gmtime
-    name = %w{year month day hour min}.collect do |method|
-      # Make sure we're at least two digits everywhere
-      "%02d" % now.send(method).to_s
-    end.join("") + ".yaml"
-
-    file = File.join(dir, name)
-
-    begin
-      Puppet::Util.replace_file(file, 0640) do |fh|
-        fh.print to_yaml
-      end
-    rescue => detail
-       Puppet.log_exception(detail, "Could not write report for #{host} at #{file}: #{detail}")
-    end
-
-    # Only testing cares about the return value
-    file
-  end
-
-  # removes all reports for a given host?
-  def self.destroy(host)
-    validate_host(host)
-
-    dir = File.join(Puppet[:reportdir], host)
-
-    if Puppet::FileSystem.exist?(dir)
-      Dir.entries(dir).each do |file|
-        next if ['.','..'].include?(file)
-        file = File.join(dir, file)
-        Puppet::FileSystem.unlink(file) if File.file?(file)
-      end
-      Dir.rmdir(dir)
-    end
-  end
-
-  def validate_host(host)
-    if host =~ Regexp.union(/[#{SEPARATOR}]/, /\A\.\.?\Z/)
-      raise ArgumentError, _("Invalid node name %{host}") % { host: host.inspect }
-    end
-  end
-  module_function :validate_host
-end

data/vendored/puppet/lib/puppet/resource.rb

@@ -1,670 +0,0 @@
-require 'puppet'
-require 'puppet/util/tagging'
-require 'puppet/parameter'
-
-# The simplest resource class.  Eventually it will function as the
-# base class for all resource-like behaviour.
-#
-# @api public
-class Puppet::Resource
-  include Puppet::Util::Tagging
-  include Puppet::Util::PsychSupport
-
-  include Enumerable
-  attr_accessor :file, :line, :catalog, :exported, :virtual, :strict
-  attr_reader :type, :title, :parameters, :rich_data_enabled
-
-  # @!attribute [rw] sensitive_parameters
-  #   @api private
-  #   @return [Array<Symbol>] A list of parameters to be treated as sensitive
-  attr_accessor :sensitive_parameters
-
-  # @deprecated
-  attr_accessor :validate_parameters
-
-  require 'puppet/indirector'
-  extend Puppet::Indirector
-  indirects :resource, :terminus_class => :ral
-
-  EMPTY_ARRAY = [].freeze
-  EMPTY_HASH = {}.freeze
-
-  ATTRIBUTES = [:file, :line, :exported].freeze
-  TYPE_CLASS = 'Class'.freeze
-  TYPE_NODE  = 'Node'.freeze
-  TYPE_SITE  = 'Site'.freeze
-
-  PCORE_TYPE_KEY = '__pcore_type__'.freeze
-  VALUE_KEY = 'value'.freeze
-
-  def self.from_data_hash(data)
-    resource = self.allocate
-    resource.initialize_from_hash(data)
-    resource
-  end
-
-  def initialize_from_hash(data)
-    raise ArgumentError, _('No resource type provided in serialized data') unless type = data['type']
-    raise ArgumentError, _('No resource title provided in serialized data') unless title = data['title']
-    @type, @title = self.class.type_and_title(type, title)
-
-    if params = data['parameters']
-      params = Puppet::Pops::Serialization::FromDataConverter.convert(params)
-      @parameters = {}
-      params.each { |param, value| self[param] = value }
-    else
-      @parameters = EMPTY_HASH
-    end
-
-    if sensitives = data['sensitive_parameters']
-      @sensitive_parameters = sensitives.map(&:to_sym)
-    else
-      @sensitive_parameters = EMPTY_ARRAY
-    end
-
-    if tags = data['tags']
-      tag(*tags)
-    end
-
-    ATTRIBUTES.each do |a|
-      value = data[a.to_s]
-      send("#{a}=", value) unless value.nil?
-    end
-  end
-
-  def inspect
-    "#{@type}[#{@title}]#{to_hash.inspect}"
-  end
-
-  def to_data_hash
-    data = {
-      'type' => type,
-      'title' => title.to_s,
-      'tags' => tags.to_data_hash
-    }
-    ATTRIBUTES.each do |param|
-      value = send(param)
-      data[param.to_s] = value unless value.nil?
-    end
-
-    data['exported'] ||= false
-
-    params = {}
-    self.to_hash.each_pair do |param, value|
-      # Don't duplicate the title as the namevar
-      unless param == namevar && value == title
-        params[param.to_s] = Puppet::Resource.value_to_json_data(value)
-      end
-    end
-
-    unless params.empty?
-      data['parameters'] = Puppet::Pops::Serialization::ToDataConverter.convert(params, {
-        :rich_data => environment.rich_data?,
-        :symbol_as_string => true,
-        :local_reference => false,
-        :type_by_reference => true,
-        :message_prefix => ref,
-        :semantic => self
-      })
-    end
-
-    data['sensitive_parameters'] = sensitive_parameters.map(&:to_s) unless sensitive_parameters.empty?
-    data
-  end
-
-  def self.value_to_json_data(value)
-    if value.is_a?(Array)
-      value.map{|v| value_to_json_data(v) }
-    elsif value.is_a?(Hash)
-      result = {}
-      value.each_pair { |k, v| result[value_to_json_data(k)] = value_to_json_data(v) }
-      result
-    elsif value.is_a?(Puppet::Resource)
-      value.to_s
-    elsif value.is_a?(Symbol) && value == :undef
-      nil
-    else
-      value
-    end
-  end
-
-  def yaml_property_munge(x)
-    self.value.to_json_data(x)
-  end
-
-  # Proxy these methods to the parameters hash.  It's likely they'll
-  # be overridden at some point, but this works for now.
-  %w{has_key? keys length delete empty? <<}.each do |method|
-    define_method(method) do |*args|
-      parameters.send(method, *args)
-    end
-  end
-
-  # Set a given parameter.  Converts all passed names
-  # to lower-case symbols.
-  def []=(param, value)
-    validate_parameter(param) if validate_parameters
-    parameters[parameter_name(param)] = value
-  end
-
-  # Return a given parameter's value.  Converts all passed names
-  # to lower-case symbols.
-  def [](param)
-    parameters[parameter_name(param)]
-  end
-
-  def ==(other)
-    return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
-
-    return false unless to_hash == other.to_hash
-    true
-  end
-
-  # Compatibility method.
-  def builtin?
-    # TODO: should be deprecated (was only used in one place in puppet codebase)
-    builtin_type?
-  end
-
-  # Is this a builtin resource type?
-  def builtin_type?
-    # Note - old implementation only checked if the resource_type was a Class
-    resource_type.is_a?(Puppet::CompilableResourceType)
-  end
-
-  # Iterate over each param/value pair, as required for Enumerable.
-  def each
-    parameters.each { |p,v| yield p, v }
-  end
-
-  def include?(parameter)
-    super || parameters.keys.include?( parameter_name(parameter) )
-  end
-
-  %w{exported virtual strict}.each do |m|
-    define_method(m+"?") do
-      self.send(m)
-    end
-  end
-
-  def class?
-    @is_class ||= @type == TYPE_CLASS
-  end
-
-  def stage?
-    @is_stage ||= @type.to_s.downcase == "stage"
-  end
-
-  # Construct a resource from data.
-  #
-  # Constructs a resource instance with the given `type` and `title`. Multiple
-  # type signatures are possible for these arguments and most will result in an
-  # expensive call to {Puppet::Node::Environment#known_resource_types} in order
-  # to resolve `String` and `Symbol` Types to actual Ruby classes.
-  #
-  # @param type [Symbol, String] The name of the Puppet Type, as a string or
-  #   symbol. The actual Type will be looked up using
-  #   {Puppet::Node::Environment#known_resource_types}. This lookup is expensive.
-  # @param type [String] The full resource name in the form of
-  #   `"Type[Title]"`. This method of calling should only be used when
-  #   `title` is `nil`.
-  # @param type [nil] If a `nil` is passed, the title argument must be a string
-  #   of the form `"Type[Title]"`.
-  # @param type [Class] A class that inherits from `Puppet::Type`. This method
-  #   of construction is much more efficient as it skips calls to
-  #   {Puppet::Node::Environment#known_resource_types}.
-  #
-  # @param title [String, :main, nil] The title of the resource. If type is `nil`, may also
-  #   be the full resource name in the form of `"Type[Title]"`.
-  #
-  # @api public
-  def initialize(type, title = nil, attributes = EMPTY_HASH)
-    @parameters = {}
-    @sensitive_parameters = []
-    if type.is_a?(Puppet::Resource)
-      # Copy constructor. Let's avoid munging, extracting, tagging, etc
-      src = type
-      self.file = src.file
-      self.line = src.line
-      self.exported = src.exported
-      self.virtual = src.virtual
-      self.set_tags(src)
-      self.environment = src.environment
-      @rstype = src.resource_type
-      @type = src.type
-      @title = src.title
-
-      src.to_hash.each do |p, v|
-        if v.is_a?(Puppet::Resource)
-          v = v.copy_as_resource
-        elsif v.is_a?(Array)
-          # flatten resource references arrays
-          v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
-          v = v.collect do |av|
-            av = av.copy_as_resource if av.is_a?(Puppet::Resource)
-            av
-          end
-        end
-
-        self[p] = v
-      end
-      @sensitive_parameters.replace(type.sensitive_parameters)
-    else
-      if type.is_a?(Hash)
-        #TRANSLATORS 'Puppet::Resource.new' should not be translated
-        raise ArgumentError, _("Puppet::Resource.new does not take a hash as the first argument.") + ' ' +
-          _("Did you mean (%{type}, %{title}) ?") %
-              { type: (type[:type] || type["type"]).inspect, title: (type[:title] || type["title"]).inspect }
-      end
-
-      # In order to avoid an expensive search of 'known_resource_types" and
-      # to obey/preserve the implementation of the resource's type - if the
-      # given type is a resource type implementation (one of):
-      #   * a "classic" 3.x ruby plugin
-      #   * a compatible implementation (e.g. loading from pcore metadata)
-      #   * a resolved user defined type
-      #
-      # ...then, modify the parameters to the "old" (agent side compatible) way
-      # of describing the type/title with string/symbols.
-      #
-      # TODO: Further optimizations should be possible as the "type juggling" is
-      # not needed when the type implementation is known.
-      #
-      if type.is_a?(Puppet::CompilableResourceType) || type.is_a?(Puppet::Resource::Type)
-        # set the resource type implementation
-        self.resource_type = type
-        # set the type name to the symbolic name
-        type = type.name
-      end
-      @exported = false
-
-      # Set things like environment, strictness first.
-      attributes.each do |attr, value|
-        next if attr == :parameters
-        send(attr.to_s + "=", value)
-      end
-
-      @type, @title = self.class.type_and_title(type, title)
-
-      rt = resource_type
-
-      if strict? && rt.nil?
-        if self.class?
-          raise ArgumentError, _("Could not find declared class %{title}") % { title: title }
-        else
-          raise ArgumentError, _("Invalid resource type %{type}") % { type: type }
-        end
-      end
-
-      params = attributes[:parameters]
-      unless params.nil? || params.empty?
-        extract_parameters(params)
-        if rt && rt.respond_to?(:deprecate_params)
-          rt.deprecate_params(title, params)
-        end
-      end
-
-      tag(self.type)
-      tag_if_valid(self.title)
-    end
-  end
-
-  def ref
-    to_s
-  end
-
-  # Find our resource.
-  def resolve
-    catalog ? catalog.resource(to_s) : nil
-  end
-
-  # A resource is an application component if it exports or consumes
-  # one or more capabilities, or if it requires a capability resource
-  def is_application_component?
-    return true if ! export.empty? || self[:consume]
-    # Array(self[:require]) does not work for Puppet::Resource instances
-    req = self[:require] || []
-    req = [ req ] unless req.is_a?(Array)
-    req.any? { |r| r.is_capability? }
-  end
-
-  # A resource is a capability (instance) if its underlying type is a
-  # capability type
-  def is_capability?
-    !resource_type.nil? && resource_type.is_capability?
-  end
-
-  # Returns the value of the 'export' metaparam as an Array
-  # @api private
-  def export
-    v = self[:export] || []
-    v.is_a?(Array) ? v : [ v ]
-  end
-
-  # The resource's type implementation
-  # @return [Puppet::Type, Puppet::Resource::Type]
-  # @api private
-  def resource_type
-    @rstype ||= self.class.resource_type(type, title, environment)
-  end
-
-  # The resource's type implementation
-  # @return [Puppet::Type, Puppet::Resource::Type]
-  # @api private
-  def self.resource_type(type, title, environment)
-    case type
-    when TYPE_CLASS; environment.known_resource_types.hostclass(title == :main ? "" : title)
-    when TYPE_NODE; environment.known_resource_types.node(title)
-    when TYPE_SITE; environment.known_resource_types.site(nil)
-    else
-      result = Puppet::Type.type(type)
-      if !result
-        krt = environment.known_resource_types
-        result = krt.definition(type) || krt.application(type)
-      end
-      result
-    end
-  end
-
-  # Set the resource's type implementation
-  # @param type [Puppet::Type, Puppet::Resource::Type]
-  # @api private
-  def resource_type=(type)
-    @rstype = type
-  end
-
-  def environment
-    @environment ||= if catalog
-                       catalog.environment_instance
-                     else
-                       Puppet.lookup(:current_environment) { Puppet::Node::Environment::NONE }
-                     end
-  end
-
-  def environment=(environment)
-    @environment = environment
-  end
-
-  # Produces a hash of attribute to value mappings where the title parsed into its components
-  # acts as the default values overridden by any parameter values explicitly given as parameters.
-  #
-  def to_hash
-    parse_title.merge parameters
-  end
-
-  def to_s
-    "#{type}[#{title}]"
-  end
-
-  def uniqueness_key
-    # Temporary kludge to deal with inconsistent use patterns; ensure we don't return nil for namevar/:name
-    h = self.to_hash
-    name = h[namevar] || h[:name] || self.name
-    h[namevar] ||= name
-    h[:name]   ||= name
-    h.values_at(*key_attributes.sort_by { |k| k.to_s })
-  end
-
-  def key_attributes
-    resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
-  end
-
-  # Convert our resource to yaml for Hiera purposes.
-  def to_hierayaml
-    # Collect list of attributes to align => and move ensure first
-    attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
-
-    attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
-      attr.delete(:ensure)
-      attr.unshift(:ensure)
-    end
-
-    attributes = attr.collect { |k|
-      v = parameters[k]
-      "    %-#{attr_max}s: %s\n" % [k, Puppet::Parameter.format_value_for_display(v)]
-    }.join
-
-    "  %s:\n%s" % [self.title, attributes]
-  end
-
-  # Convert our resource to Puppet code.
-  def to_manifest
-    # Collect list of attributes to align => and move ensure first
-    attr = parameters.keys
-    attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
-
-    attr.sort!
-    if attr.first != :ensure  && attr.include?(:ensure)
-      attr.delete(:ensure)
-      attr.unshift(:ensure)
-    end
-
-    attributes = attr.collect { |k|
-      v = parameters[k]
-      "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
-    }.join
-
-    escaped = self.title.gsub(/'/,"\\\\'")
-    "%s { '%s':\n%s}" % [self.type.to_s.downcase, escaped, attributes]
-  end
-
-  def to_ref
-    ref
-  end
-
-  # Convert our resource to a RAL resource instance.  Creates component
-  # instances for resource types that don't exist.
-  def to_ral
-    typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
-    typeklass.new(self)
-  end
-
-  def name
-    # this is potential namespace conflict
-    # between the notion of an "indirector name"
-    # and a "resource name"
-    [ type, title ].join('/')
-  end
-
-  def missing_arguments
-    resource_type.arguments.select do |param, default|
-      the_param = parameters[param.to_sym]
-      the_param.nil? || the_param.value.nil? || the_param.value == :undef
-    end
-  end
-  private :missing_arguments
-
-  # @deprecated Not used by Puppet
-  # @api private
-  def set_default_parameters(scope)
-    Puppet.deprecation_warning(_('The method Puppet::Resource.set_default_parameters is deprecated and will be removed in the next major release of Puppet.'))
-
-    return [] unless resource_type and resource_type.respond_to?(:arguments)
-
-    unless is_a?(Puppet::Parser::Resource)
-      fail Puppet::DevError, _("Cannot evaluate default parameters for %{resource} - not a parser resource") % { resource: self }
-    end
-
-    missing_arguments.collect do |param, default|
-      rtype = resource_type
-      if rtype.type == :hostclass
-        using_bound_value = false
-        catch(:no_such_key) do
-          bound_value = Puppet::Pops::Lookup.search_and_merge("#{rtype.name}::#{param}", Puppet::Pops::Lookup::Invocation.new(scope), nil)
-          # Assign bound value but don't let an undef trump a default expression
-          unless bound_value.nil? && !default.nil?
-            self[param.to_sym] = bound_value
-            using_bound_value = true
-          end
-        end
-      end
-      unless using_bound_value
-        next if default.nil?
-        self[param.to_sym] = default.safeevaluate(scope)
-      end
-      param
-    end.compact
-  end
-
-  def copy_as_resource
-    Puppet::Resource.new(self)
-  end
-
-  def valid_parameter?(name)
-    resource_type.valid_parameter?(name)
-  end
-
-  # Verify that all required arguments are either present or
-  # have been provided with defaults.
-  # Must be called after 'set_default_parameters'.  We can't join the methods
-  # because Type#set_parameters needs specifically ordered behavior.
-  #
-  # @deprecated Not used by Puppet
-  # @api private
-  def validate_complete
-    Puppet.deprecation_warning(_('The method Puppet::Resource.validate_complete is deprecated and will be removed in the next major release of Puppet.'))
-
-    return unless resource_type and resource_type.respond_to?(:arguments)
-
-    resource_type.arguments.each do |param, default|
-      param = param.to_sym
-      fail Puppet::ParseError, _("Must pass %{param} to %{resource}") % { param: param, resource: self } unless parameters.include?(param)
-    end
-
-    # Perform optional type checking
-    arg_types = resource_type.argument_types
-    # Parameters is a map from name, to parameter, and the parameter again has name and value
-    parameters.each do |name, value|
-      next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
-      unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
-        inferred_type = Puppet::Pops::Types::TypeCalculator.infer_set(value.value)
-        actual = inferred_type.generalize()
-        fail Puppet::ParseError, _("Expected parameter '%{name}' of '%{value0}' to have type %{value1}, got %{value2}") % { name: name, value0: self, value1: t.to_s, value2: actual.to_s }
-      end
-    end
-  end
-
-  def validate_parameter(name)
-    raise Puppet::ParseError.new(_("no parameter named '%{name}'") % { name: name }, file, line) unless valid_parameter?(name)
-  end
-
-  # This method, together with #file and #line, makes it possible for a Resource to be a 'source_pos' in a reported issue.
-  # @return [Integer] Instances of this class will always return `nil`.
-  def pos
-    nil
-  end
-
-  def prune_parameters(options = EMPTY_HASH)
-    properties = resource_type.properties.map(&:name)
-
-    dup.collect do |attribute, value|
-      if value.to_s.empty? or Array(value).empty?
-        delete(attribute)
-      elsif value.to_s == "absent" and attribute.to_s != "ensure"
-        delete(attribute)
-      end
-
-      parameters_to_include = options[:parameters_to_include] || []
-      delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
-    end
-    self
-  end
-
-  # @api private
-  def self.type_and_title(type, title)
-    type, title = extract_type_and_title(type, title)
-    type = munge_type_name(type)
-    if type == TYPE_CLASS
-      title = title == '' ? :main : munge_type_name(title)
-    end
-    [type, title]
-  end
-
-
-  def self.extract_type_and_title(argtype, argtitle)
-    if (argtype.nil? || argtype == :component || argtype == :whit) &&
-          argtitle =~ /^([^\[\]]+)\[(.+)\]$/m                  then [ $1,                 $2            ]
-    elsif argtitle.nil? && argtype =~ /^([^\[\]]+)\[(.+)\]$/m  then [ $1,                 $2            ]
-    elsif argtitle                                             then [ argtype,            argtitle      ]
-    elsif argtype.is_a?(Puppet::Type)                          then [ argtype.class.name, argtype.title ]
-    else  raise ArgumentError, _("No title provided and %{type} is not a valid resource reference") % { type: argtype.inspect }
-    end
-  end
-  private_class_method :extract_type_and_title
-
-  def self.munge_type_name(value)
-    return :main if value == :main
-    return TYPE_CLASS if value == '' || value.nil? || value.to_s.casecmp('component') == 0
-    Puppet::Pops::Types::TypeFormatter.singleton.capitalize_segments(value.to_s)
-  end
-  private_class_method :munge_type_name
-
-  private
-
-  # Produce a canonical method name.
-  def parameter_name(param)
-    param = param.to_s.downcase.to_sym
-    if param == :name and namevar
-      param = namevar
-    end
-    param
-  end
-
-  # The namevar for our resource type. If the type doesn't exist,
-  # always use :name.
-  def namevar
-    if builtin_type? && !(t = resource_type).nil? && t.key_attributes.length == 1
-      t.key_attributes.first
-    else
-      :name
-    end
-  end
-
-  def extract_parameters(params)
-    params.each do |param, value|
-      validate_parameter(param) if strict?
-      self[param] = value
-    end
-  end
-
-  # Produces a hash with { :key => part_of_title } for each entry in title_patterns
-  # for the resource type. A typical result for a title of 'example' is {:name => 'example'}.
-  # A resource type with a complex title to attribute mapping returns one entry in the hash
-  # per part.
-  #
-  def parse_title
-    h = {}
-    type = resource_type
-    if type.respond_to?(:title_patterns) && !type.title_patterns.nil?
-      type.title_patterns.each { |regexp, symbols_and_lambdas|
-        if captures = regexp.match(title.to_s)
-          symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
-            symbol, proc = symbol_and_lambda
-            # Many types pass "identity" as the proc; we might as well give
-            # them a shortcut to delivering that without the extra cost.
-            #
-            # Especially because the global type defines title_patterns and
-            # uses the identity patterns.
-            #
-            # This was worth about 8MB of memory allocation saved in my
-            # testing, so is worth the complexity for the API.
-            if proc then
-              h[symbol] = proc.call(capture)
-            else
-              h[symbol] = capture
-            end
-          end
-          return h
-        end
-      }
-      # If we've gotten this far, then none of the provided title patterns
-      # matched. Since there's no way to determine the title then the
-      # resource should fail here.
-      raise Puppet::Error, _("No set of title patterns matched the title \"%{title}\".") % { title: title }
-    else
-      return { :name => title.to_s }
-    end
-  end
-end