puppet 4.10.12-x64-mingw32 → 5.0.0-x64-mingw32

data/lib/puppet/indirector/resource_type.rb

@@ -1,5 +0,0 @@
-require 'puppet/resource/type'
-
-# A stub class, so our constants work.
-class Puppet::Indirector::ResourceType # :nodoc:
-end

data/lib/puppet/indirector/resource_type/parser.rb

@@ -1,108 +0,0 @@
-require 'puppet/resource/type'
-require 'puppet/indirector/code'
-require 'puppet/indirector/resource_type'
-
-# The main terminus for Puppet::Resource::Type
-#
-# This exposes the known resource types from within Puppet. Only find
-# and search are supported. When a request is received, Puppet will
-# attempt to load all resource types (by parsing manifests and modules) and
-# returns a description of the resource types found. The format of these
-# objects is documented at {Puppet::Resource::Type}.
-#
-# @api public
-class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
-  desc "Return the data-form of a resource type."
-
-  # Find will return the first resource_type with the given name. It is
-  # not possible to specify the kind of the resource type.
-  #
-  # @param request [Puppet::Indirector::Request] The request object.
-  #   The only parameters used from the request are `environment` and
-  #   `key`, which corresponds to the resource type's `name` field.
-  # @return [Puppet::Resource::Type, nil]
-  # @api public
-  def find(request)
-    Puppet.override(:squelch_parse_errors => true) do
-      krt = resource_types_in(request.environment)
-
-      # This is a bit ugly.
-      [:hostclass, :definition, :application, :node].each do |type|
-        # We have to us 'find_<type>' here because it will
-        # load any missing types from disk, whereas the plain
-        # '<type>' method only returns from memory.
-        if r = krt.send("find_#{type}", request.key)
-          return r
-        end
-      end
-      nil
-    end
-  end
-
-  # Search for resource types using a regular expression. Unlike `find`, this
-  # allows you to filter the results by the "kind" of the resource type
-  # ("class", "defined_type", or "node"). All three are searched if no
-  # `kind` filter is given. This also accepts the special string "`*`"
-  # to return all resource type objects.
-  #
-  # @param request [Puppet::Indirector::Request] The request object. The
-  #   `key` field holds the regular expression used to search, and
-  #   `options[:kind]` holds the kind query parameter to filter the
-  #   result as described above. The `environment` field specifies the
-  #   environment used to load resources.
-  #
-  # @return [Array<Puppet::Resource::Type>, nil]
-  #
-  # @api public
-  def search(request)
-    Puppet.override(:squelch_parse_errors => true) do
-
-      krt = resource_types_in(request.environment)
-      # Make sure we've got all of the types loaded.
-      krt.loader.import_all
-
-      result_candidates = case request.options[:kind]
-          when "class"
-            krt.hostclasses.values
-          when "defined_type"
-            krt.definitions.values
-          when "application"
-            krt.applications.values
-          when "node"
-            krt.nodes.values
-          when nil
-            result_candidates = [krt.hostclasses.values, krt.definitions.values, krt.applications.values, krt.nodes.values]
-          else
-            raise ArgumentError, "Unrecognized kind filter: " +
-                      "'#{request.options[:kind]}', expected one " +
-                      " of 'class', 'defined_type', 'application', or 'node'."
-        end
-
-      result = result_candidates.flatten.reject { |t| t.name == "" }
-      return nil if result.empty?
-      return result if request.key == "*"
-
-      # Strip the regex of any wrapping slashes that might exist
-      key = request.key.sub(/^\//, '').sub(/\/$/, '')
-      begin
-        regex = Regexp.new(key)
-      rescue => detail
-        raise ArgumentError, "Invalid regex '#{request.key}': #{detail}", detail.backtrace
-      end
-
-      result.reject! { |t| t.name.to_s !~ regex }
-      return nil if result.empty?
-      result
-    end
-  end
-
-  def resource_types_in(environment)
-    environment.check_for_reparse
-    environment.known_resource_types
-  end
-
-  def allow_remote_requests?
-    Puppet.deprecation_warning("The resource_type endpoint is deprecated in favor of the environment_classes endpoint. See https://docs.puppet.com/puppetserver/latest/puppet-api/v3/environment_classes.html")
-    super
-  end
-end

data/lib/puppet/indirector/resource_type/rest.rb

@@ -1,7 +0,0 @@
-require 'puppet/resource/type'
-require 'puppet/indirector/rest'
-require 'puppet/indirector/resource_type'
-
-class Puppet::Indirector::ResourceType::Rest < Puppet::Indirector::REST
-  desc "Retrieve resource types via a REST HTTP interface."
-end

data/lib/puppet/parser/yaml_trimmer.rb

@@ -1,7 +0,0 @@
-module Puppet::Parser::YamlTrimmer
-  REMOVE = [:@scope, :@source]
-
-  def to_yaml_properties
-    super - REMOVE
-  end
-end

data/lib/puppet/plugins/binding_schemes.rb

@@ -1,140 +0,0 @@
-require 'puppet/plugins'
-module Puppet::Plugins::BindingSchemes
-
-  # The lookup **key** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
-  # @api public
-  BINDINGS_SCHEMES_KEY  = 'puppet::binding::schemes'
-
-  # The lookup **type** for the multibind containing a map from scheme name to scheme handler class for bindings schemes.
-  # @api public
-  BINDINGS_SCHEMES_TYPE = 'Puppet::Plugins::BindingSchemes::BindingsSchemeHandler'
-
-  # BindingsSchemeHandler is a Puppet Extension Point for the purpose of extending Puppet with a
-  # handler of a URI scheme used in the Puppet Bindings / Injector system.
-  # The intended use is to create a class derived from this class and then register it with the
-  # Puppet Binder.
-  #
-  # Creating the Extension Class
-  # ----------------------------
-  # As an example, a class for getting LDAP data and transforming into bindings based on an LDAP URI scheme (such as RFC 2255, 4516)
-  # may be authored in say a puppet module called 'exampleorg/ldap'. The name of the class should start with `Puppetx::<user>::<module>`,
-  # e.g. 'Puppetx::Exampleorg::Ldap::LdapBindingsSchemeHandler" and
-  # be located in `lib/puppetx/exampleorg/Ldap/LdapBindingsSchemeHandler.rb`. (These rules are not enforced, but it makes the class
-  # both auto-loadable, and guaranteed to not have a name that clashes with some other LdapBindingsSchemeHandler from some other
-  # author/organization.
-  #
-  # The Puppet Binder will auto-load the file when it
-  # has a binding to the class `Puppetx::Exampleorg::Ldap::LdapBindingsSchemeHandler'
-  # The Ruby Module `Puppetx` is created by Puppet, the remaining modules should be created by the loaded logic - e.g.:
-  #
-  # @example Defining an LdapBindingsSchemeHandler
-  #   module Puppetx::Exampleorg
-  #     module Ldap
-  #       class LdapBindingsSchemeHandler < Puppetx::Puppetlabs::BindingsSchemeHandler
-  #         # implement the methods
-  #       end
-  #     end
-  #   end
-  #
-  #
-  # The expand_included method
-  # --------------------------
-  # This method is given a URI (as entered by a user in a bindings configuration) and the handler's first task is to
-  # perform checking, transformation, and possible expansion into multiple URIs for loading. The result is always an array
-  # of URIs. This method allows users to enter wild-cards, or to represent something symbolic that is transformed into one or
-  # more "real URIs" to load. (It is allowed to change scheme!).
-  # If the "optional" feature is supported, the handler should not include the URI in the result unless it will be able to produce
-  # bindings for the given URI (as an option it may produce an empty set of bindings).
-  #
-  # The expand_excluded method
-  # ---------------------------
-  # This method is given an URI (as entered by the user in a bindings configuration), and it is the handler's second task
-  # to perform checking, transformation, and possible expansion into multiple URIs that should not be loaded. The result is always
-  # an array of URIs. The user may be allowed to enter wild-cards etc. The URIs produced by this method should have the same syntax
-  # as those produced by {#expand_included} since they are excluded by comparison.
-  #
-  # The contributed_bindings method
-  # -------------------------------
-  # As the last step, the handler is being called once per URI that was included, and not later excluded to produce the
-  # contributed bindings. It is given three arguments, uri (the uri to load), scope (to provide access to the rest of the
-  # environment), and an acceptor (of issues), on which issues can be recorded.
-  #
-  # Reporting Errors/Issues
-  # -----------------------
-  # Issues are reported by calling the given composer's acceptor, which takes a severity (e.g. `:error`,
-  # `:warning`, or `:ignore`), an {Puppet::Pops::Issues::Issue Issue} instance, and a {Puppet::Pops::Adapters::SourcePosAdapter
-  # SourcePosAdapter} (which describes details about linenumber, position, and length of the problem area). If the scheme is
-  # not based on file, line, pos - nil can be passed. The URI itself can be passed as file.
-  #
-  # @example Reporting an issue
-  #    # create an issue with a symbolic name (that can serve as a reference to more details about the problem),
-  #    # make the name unique
-  #    issue = Puppet::Pops::Issues::issue(:EXAMPLEORG_LDAP_ILLEGAL_URI) { "The URI is not a valid Ldap URI" }
-  #    source_pos = nil
-  #
-  #    # report it
-  #    composer.acceptor.accept(Puppet::Pops::Validation::Diagnostic.new(:error, issue, uri.to_s, source_pos, {}))
-  #
-  # Instead of reporting issues, an exception can be raised.
-  #
-  # @abstract
-  # @api public
-  #
-  class BindingsSchemeHandler
-    # Produces the bindings contributed to the binding system based on the given URI.
-    # @param uri [URI] the URI to load bindings from
-    # @param scope [Puppet::Pops::Parser::Scope] access to scope and the rest of the environment
-    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
-    # @return [Puppet::Pops::Binder::Bindings::ContributedBindings] the bindings to contribute, most conveniently
-    #   created by calling {Puppet::Pops::Binder::BindingsFactory.contributed_bindings}.
-    # @api public
-    #
-    def contributed_bindings(uri, scope, composer)
-      raise NotImplementedError, "The BindingsProviderScheme for uri: '#{uri}' must implement 'contributed_bindings'"
-    end
-
-    # Expands the given URI for the purpose of including the bindings it refers to. The input may contain
-    # wild-cards (if supported by this handler), and it is this methods responsibility to transform such into
-    # real loadable URIs.
-    #
-    # A scheme handler that does not support optionality, or wildcards should simply return the given URI
-    # in an Array.
-    #
-    # @param uri [URI] the uri for which bindings are to be produced.
-    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
-    # @return [Array<URI>] the transformed, and possibly expanded set of URIs to include.
-    # @api public
-    #
-    def expand_included(uri, composer)
-      [uri]
-    end
-
-    # Expands the given URI for the purpose of excluding the bindings it refers to. The input may contain
-    # wild-cards (if supported by this handler), and it is this methods responsibility to transform such into
-    # real loadable URIs (that match those produced by {#expand_included} that should be excluded from the result.
-    #
-    # A scheme handler that does not support optionality, or wildcards should simply return the given URI
-    # in an Array.
-    #
-    # @param uri [URI] the uri for which bindings are to be produced.
-    # @param composer [Puppet::Pops::Binder::BindingsComposer] a composer giving access to modules by name, and a diagnostics acceptor
-    # @return [Array<URI>] the transformed, and possibly expanded set of URIs to include-
-    # @api public
-    #
-    def expand_excluded(uri, composer)
-      [uri]
-    end
-
-    # Returns whether the uri is optional or not. A scheme handler does not have to use this method
-    # to determine optionality, but if it supports such a feature, and there is no technical problem in supporting
-    # it this way, it should be done the same (or at least similar) way across all scheme handlers.
-    #
-    # This method interprets a URI ending with `?` or has query that is '?optional' as optional.
-    #
-    # @return [Boolean] whether the uri is an optional reference or not.
-    def is_optional?(uri)
-      (query = uri.query) && query == '' || query == 'optional'
-    end
-  end
-
-end

data/lib/puppet/plugins/data_providers.rb

@@ -1,45 +0,0 @@
-module Puppet::Plugins; end
-
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::Plugins::DataProviders
-
-  # The lookup **key** for the multibind containing data provider name per module
-  # @api public
-  PER_MODULE_DATA_PROVIDER_KEY       = 'puppet::module_data'
-
-  # The lookup **type** for the name of the per module data provider.
-  # @api public
-  PER_MODULE_DATA_PROVIDER_TYPE      = String
-
-  # The lookup **key** for the multibind containing map of provider name to env data provider implementation.
-  # @api public
-  ENV_DATA_PROVIDERS_KEY             = 'puppet::environment_data_providers'
-
-  # The lookup **type** for the multibind containing map of provider name to env data provider implementation.
-  # @api public
-  ENV_DATA_PROVIDERS_TYPE            = 'Puppet::Plugins::DataProviders::EnvironmentDataProvider'
-
-  # The lookup **key** for the multibind containing map of provider name to module data provider implementation.
-  # @api public
-  MODULE_DATA_PROVIDERS_KEY          = 'puppet::module_data_providers'
-
-  # The lookup **type** for the multibind containing map of provider name to module data provider implementation.
-  # @api public
-  MODULE_DATA_PROVIDERS_TYPE         = 'Puppet::Plugins::DataProviders::ModuleDataProvider'
-
-  # The lookup **key** for the multibind containing map of provider name to path based data provider factory
-  # implementation.
-  # @api public
-  PATH_BASED_DATA_PROVIDER_FACTORIES_KEY  = 'puppet::path_based_data_provider_factories'
-
-  # The lookup **type** for the multibind containing map of provider name to path based data provider factory
-  # implementation.
-  # @api public
-  PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE = 'Puppet::Plugins::DataProviders::PathBasedDataProviderFactory'
-
-end
-
-require_relative 'data_providers/data_provider'
-require_relative 'data_providers/registry'

data/lib/puppet/plugins/data_providers/data_provider.rb

@@ -1,406 +0,0 @@
-require 'puppet/pops/lookup/interpolation'
-
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::Plugins::DataProviders
-  # @deprecated
-  module DataProvider
-    include Puppet::Pops::Lookup::DataProvider
-    include Puppet::Pops::Lookup::Interpolation
-
-    def key_lookup(key, lookup_invocation, merge)
-      lookup(key.to_s, lookup_invocation, merge)
-    end
-
-    def unchecked_key_lookup(key, lookup_invocation, merge)
-      unchecked_lookup(key.to_s, lookup_invocation, merge)
-    end
-
-    # @deprecated
-    def lookup(key, lookup_invocation, merge)
-      lookup_invocation.check(key) { unchecked_lookup(key, lookup_invocation, merge) }
-    end
-
-    # Performs a lookup with the assumption that a recursive check has been made.
-    #
-    # @param key [String] The key to lookup
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @param merge [String|Hash{String => Object}] Merge strategy or hash with strategy and options
-    def unchecked_lookup(key, lookup_invocation, merge)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'DataProvider#unchecked_lookup',
-          'DataProvider#unchecked_lookup is deprecated and will be removed in the next major version of Puppet')
-      end
-      segments = split_key(key)
-      root_key = segments.shift
-      lookup_invocation.with(:data_provider, self) do
-        hash = data(data_key(root_key, lookup_invocation), lookup_invocation)
-        value = hash[root_key]
-        if value || hash.include?(root_key)
-          value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
-          lookup_invocation.report_found(key, post_process(value, lookup_invocation))
-        else
-          lookup_invocation.report_not_found(key)
-          throw :no_such_key
-        end
-      end
-    end
-
-    # Perform optional post processing of found value. The default implementation resolves
-    # interpolation expressions
-    #
-    # @param value [Object] The value to perform post processing on
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @return [Object] The result of post processing the value.
-    # @deprecated
-    def post_process(value, lookup_invocation)
-      interpolate(value, lookup_invocation, true)
-    end
-
-    # Gets the data from the compiler, or initializes it by calling #initialize_data if not present in the compiler.
-    # This means, that data is initialized once per compilation, and the data is cached for as long as the compiler
-    # lives (which is for one catalog production). This makes it possible to return data that is tailored for the
-    # request.
-    #
-    # If data is obtained using the #initialize_data method it will be sent to the #validate_data for validation
-    #
-    # @param data_key [String] The data key such as the name of a module or the constant 'environment'
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
-    # @return [Hash] The data hash for the given _key_
-    # @deprecated
-    def data(data_key, lookup_invocation)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'DataProvider#data',
-          'DataProvider#data is deprecated and will be removed in the next major version of Puppet')
-      end
-      compiler = lookup_invocation.scope.compiler
-      adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
-      adapter.data[data_key] ||= validate_data(initialize_data(data_key, lookup_invocation))
-    end
-    protected :data
-
-    # Obtain an optional key to use when retrieving the data.
-    #
-    # @param key [String] The key to lookup
-    # @return [String,nil] The data key or nil if not applicable
-    # @deprecated
-    def data_key(key, lookup_invocation)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'DataProvider#data_key',
-          'DataProvider#data_key is deprecated and will be removed in the next major version of Puppet')
-      end
-      nil
-    end
-
-    # Should be reimplemented by subclass to provide the hash that corresponds to the given name.
-    #
-    # @param data_key [String] The data key such as the name of a module or the constant 'environment'
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @return [Hash] The hash of values
-    # @deprecated
-    def initialize_data(data_key, lookup_invocation)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'DataProvider#initialize_data',
-          'DataProvider#initialize_data is deprecated and will be removed in the next major version of Puppet')
-      end
-      {}
-    end
-    protected :initialize_data
-
-    def name
-      cname = self.class.name
-      cname[cname.rindex(':')+1..-1]
-    end
-
-    # @deprecated
-    def validate_data(data, data_key)
-      data
-    end
-  end
-
-  # TODO: API 5.0 Remove this class
-  # @deprecated
-  # @api private
-  class ModuleDataProvider
-    LOOKUP_OPTIONS = 'lookup_options'.freeze
-    include DataProvider
-
-    attr_reader :module_name
-
-    def initialize(module_name = nil)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Plugins::DataProviders::ModuleDataProvider',
-          'Plugins::DataProviders::ModuleDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      @module_name = module_name || Puppet::Pops::Lookup::Invocation.current.module_name
-    end
-
-    # Retrieve the first segment of the qualified name _key_. This method will throw
-    # :no_such_key unless the segment can be extracted.
-    #
-    # @param key [String] The key
-    # @return [String] The first segment of the given key
-    # @api private
-    # @deprecated
-    def data_key(key, lookup_invocation)
-      return module_name if key == LOOKUP_OPTIONS
-      qual_index = key.index('::')
-      throw :no_such_key if qual_index.nil?
-      key[0..qual_index-1]
-    end
-
-    # Asserts that all keys in the given _data_ are prefixed with the given _module_name_. Remove entries
-    # that does not follow the convention and log a warning.
-    #
-    # @param data [Hash] The data hash
-    # @param module_name [String] The name of the module where the data was found
-    # @return [Hash] The possibly pruned hash
-    # @api public
-    def validate_data(data, module_name)
-      module_prefix = "#{module_name}::"
-      data.each_key.reduce(data) do |memo, k|
-        if k.is_a?(String)
-          next memo if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
-          msg = 'must use keys qualified with the name of the module'
-        else
-          msg = "must use keys of type String, got #{k.class.name}"
-        end
-        memo = memo.clone if memo.equal?(data)
-        memo.delete(k)
-        Puppet.warning("Module data for module '#{module_name}' #{msg}")
-        memo
-      end
-    end
-  end
-
-  # TODO: API 5.0 Remove this class
-  # @deprecated
-  # @api private
-  class EnvironmentDataProvider
-    include DataProvider
-
-    def initialize
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Plugins::DataProviders::EnvironmentDataProvider',
-          'Plugins::DataProviders::EnvironmentDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-    end
-
-    # @api private
-    # @deprecated
-    def data_key(key, lookup_invocation)
-      'environment'
-    end
-  end
-
-  # Class that keeps track of the original path (as it appears in the declaration, before interpolation),
-  # the fully resolved path, and whether or the resolved path exists.
-  #
-  # @api private
-  # @deprecated
-  class ResolvedPath
-    attr_reader :original_path, :path
-
-    # @param original_path [String] path as found in declaration. May contain interpolation expressions
-    # @param path [Pathname] the expanded absolute path
-    # @deprecated
-    def initialize(original_path, path)
-      @original_path = original_path
-      @path = path
-      @exists = nil
-    end
-
-    # @return [Boolean] cached info if the path exists or not
-    # @deprecated
-    def exists?
-      @exists = @path.exist? if @exists.nil?
-      @exists
-    end
-    alias exist? exists?
-  end
-
-  # A data provider that is initialized with a set of _paths_. When performing lookup, each
-  # path is search in the order they appear. If a value is found in more than one location it
-  # will be merged according to a given (optional) merge strategy.
-  #
-  # @abstract
-  # @api private
-  # @deprecated
-  class PathBasedDataProvider
-    include DataProvider
-
-    attr_reader :name
-
-    # @param name [String] The name of the data provider
-    # @param paths [Array<ResolvedPath>] Paths used by this provider
-    # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
-    # @deprecated
-    def initialize(name, paths, parent_data_provider = nil)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'PathBasedDataProvider',
-          'PathBasedDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      @name = name
-      @paths = paths
-      @parent_data_provider = parent_data_provider
-    end
-
-    # Gets the data from the compiler, or initializes it by calling #initialize_data if not present in the compiler.
-    # This means, that data is initialized once per compilation, and the data is cached for as long as the compiler
-    # lives (which is for one catalog production). This makes it possible to return data that is tailored for the
-    # request.
-    #
-    # If data is obtained using the #initialize_data method it will be sent to the #validate_data for validation
-    #
-    # @param path [String] The path to the data to be loaded (passed to #initialize_data)
-    # @param data_key [String] The data key such as the name of a module or the constant 'environment'
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @param merge [String|Hash<String,Object>|nil] Merge strategy or hash with strategy and options
-    # @return [Hash] The data hash for the given _key_
-    # @deprecated
-    def load_data(path, data_key, lookup_invocation)
-      compiler = lookup_invocation.scope.compiler
-      adapter = Puppet::DataProviders::DataAdapter.get(compiler) || Puppet::DataProviders::DataAdapter.adapt(compiler)
-      adapter.data[path] ||= validate_data(initialize_data(path, lookup_invocation), data_key)
-    end
-    protected :data
-
-    # @deprecated
-    def validate_data(data, module_name)
-      @parent_data_provider.nil? ? data : @parent_data_provider.validate_data(data, module_name)
-    end
-
-    # Performs a lookup by searching all given paths for the given _key_. A merge will be performed if
-    # the value is found in more than one location and _merge_ is not nil.
-    #
-    # @param key [String] The key to lookup
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
-    # @deprecated
-    def unchecked_lookup(key, lookup_invocation, merge)
-      segments = split_key(key)
-      root_key = segments.shift
-
-      module_name = @parent_data_provider.nil? ? nil : @parent_data_provider.data_key(key, lookup_invocation)
-      lookup_invocation.with(:data_provider, self) do
-        merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
-        lookup_invocation.with(:merge, merge_strategy) do
-          merged_result = merge_strategy.merge_lookup(@paths) do |path|
-            lookup_invocation.with(:location, path) do
-              if path.exists?
-                hash = load_data(path.path, module_name, lookup_invocation)
-                value = hash[root_key]
-                if value || hash.include?(root_key)
-                  value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
-                  lookup_invocation.report_found(key, post_process(value, lookup_invocation))
-                else
-                  lookup_invocation.report_not_found(key)
-                  throw :no_such_key
-                end
-              else
-                lookup_invocation.report_location_not_found
-                throw :no_such_key
-              end
-            end
-          end
-          lookup_invocation.report_result(merged_result)
-        end
-      end
-    end
-  end
-
-  # TODO: API 5.0 Remove this class
-  # Factory for creating path based data providers
-  #
-  # @abstract
-  # @api private
-  # @deprecated
-  class PathBasedDataProviderFactory
-    # @deprecated
-    def initialize
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'PathBasedDataProviderFactory',
-        'PathBasedDataProviderFactory is deprecated and will be removed in the next major version of Puppet')
-      end
-    end
-
-    # Create a path based data provider with the given _name_ and _paths_
-    #
-    # @param name [String] the name of the created provider (for logging and debugging)
-    # @param paths [Array<String>] array of resolved paths
-    # @param parent_data_provider [DataProvider] The data provider that is the container of this data provider
-    # @return [DataProvider] The created data provider
-    # @deprecated
-    def create(name, paths, parent_data_provider)
-      raise NotImplementedError, "Subclass of PathBasedDataProviderFactory must implement 'create' method"
-    end
-
-    # Resolve the given _paths_ to something that is meaningful as a _paths_ argument when creating
-    # a provider using the #create call.
-    #
-    # In order to increase efficiency, the implementors of this method should ensure that resolved
-    # paths that exists are included in the result.
-    #
-    # @param datadir [Pathname] The base when creating absolute paths
-    # @param declared_paths [Array<String>] paths as found in declaration. May contain interpolation expressions
-    # @param paths [Array<String>] paths that have been preprocessed (interpolations resolved)
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @return [Array<ResolvedPath>] Array of resolved paths
-    # @deprecated
-    def resolve_paths(datadir, declared_paths, paths, lookup_invocation)
-      []
-    end
-
-    # Returns the data provider factory version.
-    #
-    # return [Integer] the version of this data provider factory
-    def version
-      2
-    end
-  end
-
-  # TODO: API 5.0 Remove this class
-  # Factory for creating file based data providers. This is an extension of the path based
-  # factory where it is required that each resolved path appoints an existing file in the local
-  # file system.
-  #
-  # @abstract
-  # @api private
-  # @deprecated
-  class FileBasedDataProviderFactory < PathBasedDataProviderFactory
-    # @deprecated
-    def initialize
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'FileBasedDataProviderFactory',
-          'FileBasedDataProviderFactory is deprecated and will be removed in the next major version of Puppet')
-      end
-    end
-
-    # @param datadir [Pathname] The base when creating absolute paths
-    # @param declared_paths [Array<String>] paths as found in declaration. May contain interpolation expressions
-    # @param paths [Array<String>] paths that have been preprocessed (interpolations resolved)
-    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
-    # @return [Array<Puppet::DataProviders::ResolvedLocation>] Array of resolved paths
-    # @deprecated
-    def resolve_paths(datadir, declared_paths, paths, lookup_invocation)
-      resolved_paths = []
-      unless paths.nil? || datadir.nil?
-        ext = path_extension
-        paths.each_with_index do |path, idx|
-          path = path + ext unless path.end_with?(ext)
-          path = datadir + path
-          resolved_paths << Puppet::Pops::Lookup::ResolvedLocation.new(declared_paths[idx], path, path.exist?)
-        end
-      end
-      resolved_paths
-    end
-
-    # @deprecated
-    def path_extension
-      raise NotImplementedError, "Subclass of FileBasedProviderFactory must implement 'path_extension' method"
-    end
-    protected :path_extension
-  end
-end