puppet 4.0.0 → 4.5.0

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

@@ -0,0 +1,336 @@
+require 'puppet/pops/lookup/interpolation'
+
+module Puppet::Plugins::DataProviders
+  module DataProvider
+    include Puppet::Pops::Lookup::Interpolation
+
+    # Performs a lookup with an endless recursion check.
+    #
+    # @param key [String] The key to lookup
+    # @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
+    #
+    # @api public
+    def lookup(name, lookup_invocation, merge)
+      lookup_invocation.check(name) { unchecked_lookup(name, 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>|nil] Merge strategy or hash with strategy and options
+    #
+    # @api public
+    def unchecked_lookup(key, lookup_invocation, merge)
+      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.
+    #
+    # @api public
+    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_
+    #
+    # @api public
+    def data(data_key, lookup_invocation)
+      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), data_key)
+    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
+    #
+    # @api public
+    def data_key(key, lookup_invocation)
+      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
+    #
+    # @api public
+    def initialize_data(data_key, lookup_invocation)
+      {}
+    end
+    protected :initialize_data
+
+    def name
+      cname = self.class.name
+      cname[cname.rindex(':')+1..-1]
+    end
+
+    def validate_data(data, data_key)
+      data
+    end
+  end
+
+  class ModuleDataProvider
+    LOOKUP_OPTIONS = Puppet::Pops::Lookup::LOOKUP_OPTIONS
+    include DataProvider
+
+    # 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
+    def data_key(key, lookup_invocation)
+      return lookup_invocation.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
+
+  class EnvironmentDataProvider
+    include DataProvider
+
+    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 public
+  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 absolue path
+    # @api public
+    def initialize(original_path, path)
+      @original_path = original_path
+      @path = path
+      @exists = nil
+    end
+
+    # @return [Boolean] cached info if the path exists or not
+    # @api public
+    def exists?
+      @exists = @path.exist? if @exists.nil?
+      @exists
+    end
+  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 public
+  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
+    #
+    # @api public
+    def initialize(name, paths, parent_data_provider = nil)
+      @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_
+    #
+    # @api public
+    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
+
+    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
+    #
+    # @api public
+    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(:path, 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_path_not_found
+                throw :no_such_key
+              end
+            end
+          end
+          lookup_invocation.report_result(merged_result)
+        end
+      end
+    end
+  end
+
+  # Factory for creating path based data providers
+  #
+  # @abstract
+  # @api public
+  class PathBasedDataProviderFactory
+    # 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
+    #
+    # @api public
+    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
+    #
+    # @api public
+    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
+    # @api public
+    def version
+      2
+    end
+  end
+
+  # 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 public
+  class FileBasedDataProviderFactory < PathBasedDataProviderFactory
+    # @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
+    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)
+          resolved_paths << ResolvedPath.new(declared_paths[idx], datadir + path)
+        end
+      end
+      resolved_paths
+    end
+
+    def path_extension
+      raise NotImplementedError, "Subclass of FileBasedProviderFactory must implement 'path_extension' method"
+    end
+    protected :path_extension
+  end
+end

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

@@ -0,0 +1,84 @@
+module Puppet::Plugins::DataProviders
+  class Registry
+    def self.register_extensions(extensions)
+      extensions.multibind(PER_MODULE_DATA_PROVIDER_KEY).name(PER_MODULE_DATA_PROVIDER_KEY).hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
+      extensions.multibind(ENV_DATA_PROVIDERS_KEY).name(ENV_DATA_PROVIDERS_KEY).hash_of(ENV_DATA_PROVIDERS_TYPE)
+      extensions.multibind(MODULE_DATA_PROVIDERS_KEY).name(MODULE_DATA_PROVIDERS_KEY).hash_of(MODULE_DATA_PROVIDERS_TYPE)
+      extensions.multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).name(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).hash_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE)
+    end
+
+    def self.hash_of_per_module_data_provider
+      @@HASH_OF_PER_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
+    end
+
+    def self.hash_of_module_data_providers
+      @@HASH_OF_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(MODULE_DATA_PROVIDERS_TYPE))
+    end
+
+    def self.hash_of_environment_data_providers
+      @@HASH_OF_ENV_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(ENV_DATA_PROVIDERS_TYPE))
+    end
+
+    def self.hash_of_path_based_data_provider_factories
+      @@HASH_OF_PATH_BASED_DATA_PROVIDER_FACTORIES ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE))
+    end
+
+    # Registers a 'none' environment data provider, and a 'none' module data provider as the defaults.
+    # This is only done to allow that something binds to 'none' rather than removing the entire binding (which
+    # has the same effect).
+    #
+    def self.register_defaults(default_bindings)
+      default_bindings.bind do
+        name('none')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance(ENV_DATA_PROVIDERS_TYPE)
+      end
+
+      default_bindings.bind do
+        name('function')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::FunctionEnvDataProvider')
+      end
+
+      default_bindings.bind do
+        name('hiera')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::HieraEnvDataProvider')
+      end
+
+      default_bindings.bind do
+        name('none')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance(MODULE_DATA_PROVIDERS_TYPE)
+      end
+
+      default_bindings.bind do
+        name('function')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::FunctionModuleDataProvider')
+      end
+
+      default_bindings.bind do
+        name('hiera')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::HieraModuleDataProvider')
+      end
+
+      default_bindings.bind do
+        name('json')
+        in_multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)
+        to_instance('Puppet::DataProviders::JsonDataProviderFactory')
+      end
+
+      default_bindings.bind do
+        name('yaml')
+        in_multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)
+        to_instance('Puppet::DataProviders::YamlDataProviderFactory')
+      end
+    end
+  end
+end
+

data/lib/puppet/plugins/data_providers.rb

@@ -1,6 +1,6 @@
 module Puppet::Plugins; end
 
-class Puppet::Plugins::DataProviders
+module Puppet::Plugins::DataProviders
 
   # The lookup **key** for the multibind containing data provider name per module
   # @api public
@@ -26,65 +26,17 @@ class Puppet::Plugins::DataProviders
   # @api public
   MODULE_DATA_PROVIDERS_TYPE         = 'Puppet::Plugins::DataProviders::ModuleDataProvider'
 
-  def self.register_extensions(extensions)
-    extensions.multibind(PER_MODULE_DATA_PROVIDER_KEY).name(PER_MODULE_DATA_PROVIDER_KEY).hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
-    extensions.multibind(ENV_DATA_PROVIDERS_KEY).name(ENV_DATA_PROVIDERS_KEY).hash_of(ENV_DATA_PROVIDERS_TYPE)
-    extensions.multibind(MODULE_DATA_PROVIDERS_KEY).name(MODULE_DATA_PROVIDERS_KEY).hash_of(MODULE_DATA_PROVIDERS_TYPE)
-  end
-
-  def self.hash_of_per_module_data_provider
-    @@HASH_OF_PER_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
-  end
-
-  def self.hash_of_module_data_providers
-    @@HASH_OF_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
-      Puppet::Pops::Types::TypeFactory.type_of(MODULE_DATA_PROVIDERS_TYPE))
-  end
-
-  def self.hash_of_environment_data_providers
-    @@HASH_OF_ENV_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
-      Puppet::Pops::Types::TypeFactory.type_of(ENV_DATA_PROVIDERS_TYPE))
-  end
-
-  # Registers a 'none' environment data provider, and a 'none' module data provider as the defaults.
-  # This is only done to allow that something binds to 'none' rather than removing the entire binding (which
-  # has the same effect).
-  #
-  def self.register_defaults(default_bindings)
-    default_bindings.bind do
-      name('none')
-      in_multibind(ENV_DATA_PROVIDERS_KEY)
-      to_instance(ENV_DATA_PROVIDERS_TYPE)
-    end
-
-    default_bindings.bind do
-      name('function')
-      in_multibind(ENV_DATA_PROVIDERS_KEY)
-      to_instance('Puppet::DataProviders::FunctionEnvDataProvider')
-    end
-
-    default_bindings.bind do
-      name('none')
-      in_multibind(MODULE_DATA_PROVIDERS_KEY)
-      to_instance(MODULE_DATA_PROVIDERS_TYPE)
-    end
-
-    default_bindings.bind do
-      name('function')
-      in_multibind(MODULE_DATA_PROVIDERS_KEY)
-      to_instance('Puppet::DataProviders::FunctionModuleDataProvider')
-    end
-  end
+  # 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'
 
-  class ModuleDataProvider
-    def lookup(name, scope, merge)
-      throw :no_such_key
-    end
-  end
+  # 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'
 
-  class EnvironmentDataProvider
-    def lookup(name, scope, merge)
-      throw :no_such_key
-    end
-  end
 end
+
+require_relative 'data_providers/data_provider'
+require_relative 'data_providers/registry'

data/lib/puppet/pops/adaptable.rb

@@ -15,7 +15,8 @@
 #   be exploited as the implementation of _being adaptable_ may change in the future.
 # @api private
 #
-module Puppet::Pops::Adaptable
+module Puppet::Pops
+module Adaptable
   # Base class for an Adapter.
   #
   # A typical adapter just defines some accessors.
@@ -199,3 +200,5 @@ module Puppet::Pops::Adaptable
     end
   end
 end
+end
+

data/lib/puppet/pops/adapters.rb

@@ -1,11 +1,12 @@
 # The Adapters module contains adapters for Documentation, Origin, SourcePosition, and Loader.
 #
-module Puppet::Pops::Adapters
+module Puppet::Pops
+module Adapters
   # A documentation adapter adapts an object with a documentation string.
   # (The intended use is for a source text parser to extract documentation and store this
   # in DocumentationAdapter instances).
   #
-  class DocumentationAdapter < Puppet::Pops::Adaptable::Adapter
+  class DocumentationAdapter < Adaptable::Adapter
     # @return [String] The documentation associated with an object
     attr_accessor :documentation
   end
@@ -19,10 +20,11 @@ module Puppet::Pops::Adapters
   # @note It is relatively expensive to compute line and position on line - it is not something that
   #   should be done for every token or model object.
   #
-  # @see Puppet::Pops::Utils#find_adapter, Puppet::Pops::Utils#find_closest_positioned
+  # @see Utils#find_adapter, Utils#find_closest_positioned
   #
-  class SourcePosAdapter < Puppet::Pops::Adaptable::Adapter
+  class SourcePosAdapter < Adaptable::Adapter
     attr_accessor :locator
+    attr_reader :adapted
 
     def self.create_adapter(o)
       new(o)
@@ -44,10 +46,10 @@ module Puppet::Pops::Adapters
         raise ArgumentError, "InternalError: SourcePosAdapter for something that has no locator among parents"
       end
       case
-      when o.is_a?(Puppet::Pops::Model::Program)
+      when o.is_a?(Model::Program)
         return o.locator
       # TODO_HEREDOC use case of SubLocator instead
-      when o.is_a?(Puppet::Pops::Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
+      when o.is_a?(Model::SubLocatedExpression) && !(found_locator = o.locator).nil?
         return found_locator
       when adapter = self.class.get(o)
         return adapter.locator
@@ -82,28 +84,110 @@ module Puppet::Pops::Adapters
 
     # Extracts the text represented by this source position (the string is obtained from the locator)
     def extract_text
-      locator.string.slice(offset, length)
+      locator.extract_text(offset, length)
+    end
+
+    def extract_tree_text
+      first = @adapted.offset
+      last = first + @adapted.length
+      @adapted.eAllContents.each do |m|
+        m_offset = m.offset
+        next if m_offset.nil?
+        first = m_offset if m_offset < first
+        m_last = m_offset + m.length
+        last = m_last if m_last > last
+      end
+      locator.extract_text(first, last-first)
     end
 
     # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
     def to_uri
       f = locator.file
-      f = 'string:' if f.nil? || f.empty?
+      if f.nil? || f.empty?
+        f = 'string:'
+      else
+        f = Puppet::Util.path_to_uri(f).to_s
+      end
       URI("#{f}?line=#{line.to_s}&pos=#{pos.to_s}")
     end
   end
 
-  # A LoaderAdapter adapts an object with a {Puppet::Pops::Loader}. This is used to make further loading from the
+  # A LoaderAdapter adapts an object with a {Loader}. This is used to make further loading from the
   # perspective of the adapted object take place in the perspective of this Loader.
   #
   # It is typically enough to adapt the root of a model as a search is made towards the root of the model
   # until a loader is found, but there is no harm in duplicating this information provided a contained
   # object is adapted with the correct loader.
   #
-  # @see Puppet::Pops::Utils#find_adapter
+  # @see Utils#find_adapter
   #
-  class LoaderAdapter < Puppet::Pops::Adaptable::Adapter
-    # @return [Puppet::Pops::Loader::Loader] the loader
+  class LoaderAdapter < Adaptable::Adapter
+    # @return [Loader::Loader] the loader
     attr_accessor :loader
+
+    # Finds the loader to use when loading originates from the source position of the given argument.
+    #
+    # @param instance [Model::PopsObject] The model object
+    # @param scope [Puppet::Parser::Scope] The scope to use
+    # @return [Loader,nil] the found loader or `nil` if it could not be found
+    #
+    def self.loader_for_model_object(model, scope)
+      # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
+      adapter = Utils.find_adapter(model, self)
+      return adapter.loader unless adapter.nil?
+
+      if scope.nil?
+        loaders = Puppet.lookup(:loaders) { nil }
+        loaders.nil? ? nil : loaders.private_environment_loader
+      else
+        # Use source location to determine calling module, or use the private_environment_loader (sees env + all modules)
+        # This is necessary since not all .pp files are loaded by a Loader (see PUP-1833)
+        adapter = adapt_by_source(scope, model)
+        adapter.nil? ? scope.compiler.loaders.private_environment_loader : adapter.loader
+      end
+    end
+
+    # Attempts to find the module that `instance` originates from by looking at it's {SourcePosAdapter} and
+    # compare the `locator.file` found there with the module paths given in the environment found in the
+    # given `scope`. If the file is found to be relative to a path, then the first segment of the relative
+    # path is interpreted as the name of a module. The object that the {SourcePosAdapter} is adapted to
+    # will then be adapted to the private loader for that module and that adapter is returned.
+    #
+    # The method returns `nil` when no module could be found.
+    #
+    # @param scope
+    # @param instance
+    def self.adapt_by_source(scope, instance)
+      source_pos = Utils.find_adapter(instance, SourcePosAdapter)
+      unless source_pos.nil?
+        mod = find_module_for_file(scope.environment, source_pos.locator.file)
+        unless mod.nil?
+          adapter = LoaderAdapter.adapt(source_pos.adapted)
+          adapter.loader = scope.compiler.loaders.private_loader_for_module(mod.name)
+          return adapter
+        end
+      end
+      nil
+    end
+
+    def self.find_module_for_file(environment, file)
+      return nil if file.nil?
+      file_path = Pathname.new(file)
+      environment.modulepath.each do |path|
+        begin
+          relative_path = file_path.relative_path_from(Pathname.new(path)).to_s.split(File::SEPARATOR)
+        rescue ArgumentError
+          # file_path was not relative to the module_path. That's OK.
+          next
+        end
+        if relative_path.length > 1
+          mod = environment.module(relative_path[0])
+          return mod unless mod.nil?
+        end
+      end
+      nil
+    end
+    private_class_method :find_module_for_file
   end
 end
+end