puppet 8.3.1-x64-mingw32 → 8.4.0-x64-mingw32

data/lib/puppet/pops/loader/module_loaders.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # =ModuleLoaders
@@ -20,7 +21,6 @@ module Loader
 # @api private
 #
 module ModuleLoaders
-
   # Wildcard module name for module loaders, makes loading possible from any namespace.
   NAMESPACE_WILDCARD = '*'
 
@@ -30,12 +30,12 @@ module ModuleLoaders
   #
   def self.cached_loader_from(parent_loader, loaders)
     LibRootedFileBased.new(parent_loader,
-      loaders,
-      NAMESPACE_WILDCARD,
-      Puppet[:libdir],
-      'cached_puppet_lib',
-      [:func_4x, :func_3x, :datatype]
-    )
+                           loaders,
+                           NAMESPACE_WILDCARD,
+                           Puppet[:libdir],
+                           'cached_puppet_lib',
+                           [:func_4x, :func_3x, :datatype]
+                          )
   end
 
   def self.system_loader_from(parent_loader, loaders)
@@ -48,9 +48,9 @@ module ModuleLoaders
     LibRootedFileBased.new(parent_loader,
                            loaders,
                            nil,
-                           puppet_lib,   # may or may not have a 'lib' above 'puppet'
+                           puppet_lib, # may or may not have a 'lib' above 'puppet'
                            'puppet_system',
-                           [:func_4x, :func_3x, :datatype]   # only load ruby functions and types from "puppet"
+                           [:func_4x, :func_3x, :datatype] # only load ruby functions and types from "puppet"
                           )
   end
 
@@ -59,30 +59,30 @@ module ModuleLoaders
       EmptyLoader.new(parent_loader, ENVIRONMENT, loaders.environment)
     else
       FileBased.new(parent_loader,
-        loaders,
-        ENVIRONMENT,
-        env_path,
-        ENVIRONMENT
-      )
+                    loaders,
+                    ENVIRONMENT,
+                    env_path,
+                    ENVIRONMENT
+                   )
     end
   end
 
   def self.module_loader_from(parent_loader, loaders, module_name, module_path)
     ModuleLoaders::FileBased.new(parent_loader,
-                                                       loaders,
-                                                       module_name,
-                                                       module_path,
-                                                       module_name
-                                                       )
+                                 loaders,
+                                 module_name,
+                                 module_path,
+                                 module_name
+                                )
   end
 
   def self.pcore_resource_type_loader_from(parent_loader, loaders, environment_path)
     ModuleLoaders::FileBased.new(parent_loader,
-      loaders,
-      nil,
-      environment_path,
-      'pcore_resource_types'
-    )
+                                 loaders,
+                                 nil,
+                                 environment_path,
+                                 'pcore_resource_types'
+                                )
   end
 
   class EmptyLoader < BaseLoader
@@ -100,11 +100,9 @@ module ModuleLoaders
   end
 
   class AbstractPathBasedModuleLoader < BaseLoader
-
     # The name of the module, or nil, if this is a global "component", or "any module" if set to the `NAMESPACE_WILDCARD` (*)
     attr_reader :module_name
 
-
     # The path to the location of the module/component - semantics determined by subclass
     attr_reader :path
 
@@ -136,9 +134,10 @@ module ModuleLoaders
       @loaders = loaders
       @loadables = loadables
       unless (loadables - LOADABLE_KINDS).empty?
-        #TRANSLATORS 'loadables' is a variable containing loadable modules and should not be translated
+        # TRANSLATORS 'loadables' is a variable containing loadable modules and should not be translated
         raise ArgumentError, _('given loadables are not of supported loadable kind')
       end
+
       loaders.add_loader_by_name(self)
     end
 
@@ -153,6 +152,7 @@ module ModuleLoaders
           relative_paths(sp).each do |rp|
             tp = sp.typed_name(type, name_authority, rp, global ? nil : @module_name)
             next unless sp.valid_name?(tp)
+
             begin
               load_typed(tp) unless block_given? && !block.yield(tp)
             rescue StandardError => e
@@ -405,6 +405,7 @@ module ModuleLoaders
       is_global = global?
       smart_paths.effective_paths(typed_name.type).each do |sp|
         next unless sp.valid_name?(typed_name)
+
         origin = sp.effective_path(typed_name, is_global ? 0 : 1)
         unless origin.nil?
           if sp.fuzzy_matching?
@@ -431,7 +432,6 @@ module ModuleLoaders
   # @api private
   #
   class FileBased < AbstractPathBasedModuleLoader
-
     attr_reader :smart_paths
     attr_reader :path_index
 

data/lib/puppet/pops/loader/predefined_loader.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Puppet::Pops::Loader
 
+module Puppet::Pops::Loader
 # A PredefinedLoader is a loader that is manually populated with loaded elements
 # before being used. It never loads anything on its own.
 #
@@ -25,5 +25,4 @@ class PredefinedLoader < BaseLoader
     yield
   end
 end
-
 end

data/lib/puppet/pops/loader/puppet_function_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # The PuppetFunctionInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
@@ -34,6 +35,7 @@ class PuppetFunctionInstantiator
     unless the_function_definition.is_a?(Model::FunctionDefinition)
       raise ArgumentError, _("The code loaded from %{source_ref} does not define the function '%{type_name}' - no function found.") % { source_ref: source_ref, type_name: typed_name.name }
     end
+
     unless the_function_definition.name == typed_name.name
       expected = typed_name.name
       actual = the_function_definition.name
@@ -76,8 +78,8 @@ class PuppetFunctionInstantiator
     Puppet::Functions.create_function(function_definition.name, Puppet::Functions::PuppetFunction) do
       # TODO: should not create a new evaluator per function
       init_dispatch(Evaluator::Closure::Named.new(
-        function_definition.name,
-        Evaluator::EvaluatorImpl.new(), function_definition))
+                      function_definition.name,
+                      Evaluator::EvaluatorImpl.new(), function_definition))
     end
   end
 end

data/lib/puppet/pops/loader/puppet_plan_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # The PuppetPlanInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
@@ -43,6 +44,7 @@ class PuppetPlanInstantiator
     unless the_plan_definition.is_a?(Model::PlanDefinition)
       raise ArgumentError, _("The code loaded from %{source_ref} does not define the plan '%{plan_name}' - no plan found.") % { source_ref: source_ref, plan_name: typed_name.name }
     end
+
     unless the_plan_definition.name == typed_name.name
       expected = typed_name.name
       actual = the_plan_definition.name
@@ -85,8 +87,8 @@ class PuppetPlanInstantiator
     Puppet::Functions.create_function(plan_definition.name, Puppet::Functions::PuppetFunction) do
       # TODO: should not create a new evaluator per function
       init_dispatch(Evaluator::Closure::Named.new(
-        plan_definition.name,
-        Evaluator::EvaluatorImpl.new(), plan_definition))
+                      plan_definition.name,
+                      Evaluator::EvaluatorImpl.new(), plan_definition))
     end
   end
 end

data/lib/puppet/pops/loader/puppet_resource_type_impl_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # The PuppetResourceTypeImplInstantiator instantiates a Puppet::Pops::ResourceTypeImpl object.
@@ -74,7 +75,6 @@ class PuppetResourceTypeImplInstantiator
     Adapters::LoaderAdapter.adapt(resource_type_impl).loader_name = loader.loader_name
     resource_type_impl
   end
-
 end
 end
 end

data/lib/puppet/pops/loader/ruby_data_type_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The RubyTypeInstantiator instantiates a data type from the ruby source
 # that calls Puppet::DataTypes.create_type.
 #
@@ -17,16 +18,18 @@ class Puppet::Pops::Loader::RubyDataTypeInstantiator
     unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:DataTypes\.create_type/
       raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 5x API data type - no create_type call.") % { source_ref: source_ref }
     end
+
     # make the private loader available in a binding to allow it to be passed on
     loader_for_type = loader.private_loader
     here = get_binding(loader_for_type)
-    created = eval(ruby_code_string, here, source_ref, 1)
+    created = eval(ruby_code_string, here, source_ref, 1) # rubocop:disable Security/Eval
     unless created.is_a?(Puppet::Pops::Types::PAnyType)
       raise ArgumentError, _("The code loaded from %{source_ref} did not produce a data type when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
     end
     unless created.name.casecmp(typed_name.name) == 0
       raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected '%{type_name}', got %{created_name}") % { source_ref: source_ref, type_name: typed_name.name, created_name: created.name }
     end
+
     created
   end
 

data/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The RubyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
 # that calls Puppet::Functions.create_function.
 #
@@ -17,16 +18,18 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
       raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 4x API function - no create_function call.") % { source_ref: source_ref }
     end
+
     # make the private loader available in a binding to allow it to be passed on
     loader_for_function = loader.private_loader
     here = get_binding(loader_for_function)
-    created = eval(ruby_code_string, here, source_ref, 1)
+    created = eval(ruby_code_string, here, source_ref, 1) # rubocop:disable Security/Eval
     unless created.is_a?(Class)
       raise ArgumentError, _("The code loaded from %{source_ref} did not produce a Function class when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
     end
     unless created.name.to_s == typed_name.name()
       raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected '%{type_name}', got %{created_name}") % { source_ref: source_ref, type_name: typed_name.name, created_name: created.name }
     end
+
     # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
     # when calling functions etc.
     # It should be bound to global scope

data/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
 # that calls Puppet::Functions.create_function.
 #
@@ -38,13 +39,14 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
       # This will do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
       # in the anonymous module used to hold function definitions.
       #
-      func_info = eval(ruby_code_string, here, source_ref, 1)
+      func_info = eval(ruby_code_string, here, source_ref, 1) # rubocop:disable Security/Eval
 
       # Validate what was loaded
       unless func_info.is_a?(Hash)
         # TRANSLATORS - the word 'newfunction' should not be translated as it is a method name.
         raise ArgumentError, _("Illegal legacy function definition! The code loaded from %{source_ref} did not return the result of calling 'newfunction'. Got '%{klass}'") % { source_ref: source_ref, klass: func_info.class }
       end
+
       unless func_info[:name] == "function_#{typed_name.name()}"
         raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got '%{created_name}'") % { 
           source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
@@ -72,7 +74,8 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
 
   def self.assert_code(code_string, source_ref, result)
     ripped = Ripper.sexp(code_string)
-    return false if ripped.nil?  # Let the next real parse crash and tell where and what is wrong
+    return false if ripped.nil? # Let the next real parse crash and tell where and what is wrong
+
     ripped.each {|x| walk(x, source_ref, result) }
     true
   end
@@ -80,6 +83,7 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
 
   def self.walk(x, source_ref, result)
     return unless x.is_a?(Array)
+
     first = x[0]
     case first
     when :fcall, :call

data/lib/puppet/pops/loader/runtime3_type_loader.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
-
 # Runtime3TypeLoader
 # ===
 # Loads a resource type using the 3.x type loader
@@ -31,6 +31,7 @@ class Runtime3TypeLoader < BaseLoader
   #
   def find(typed_name)
     return nil unless typed_name.name_authority == Pcore::RUNTIME_NAME_AUTHORITY
+
     case typed_name.type
     when :type
       value = nil
@@ -98,7 +99,6 @@ class Runtime3TypeLoader < BaseLoader
   def allow_shadowing?
     true
   end
-
 end
 end
 end

data/lib/puppet/pops/loader/simple_environment_loader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # SimpleEnvironmentLoader
 # ===
 # This loader does not load anything and it is populated by the bootstrapping logic that loads
@@ -6,7 +7,6 @@
 # and what is loaded here overrides any child loaders (modules).
 #
 class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::BaseLoader
-
   attr_accessor :private_loader
 
   # Never finds anything, everything "loaded" is set externally
@@ -17,5 +17,4 @@ class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::Base
   def to_s()
     "(SimpleEnvironmentLoader '#{loader_name}')"
   end
-
 end

data/lib/puppet/pops/loader/static_loader.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
-  # Static Loader contains constants, basic data types and other types required for the system
-  # to boot.
-  #
+
+# Static Loader contains constants, basic data types and other types required for the system
+# to boot.
+#
 module Puppet::Pops
 module Loader
 class StaticLoader < Loader
-
   BUILTIN_TYPE_NAMES = %w{
-      Component
-      Exec
-      File
-      Filebucket
-      Group
-      Node
-      Notify
-      Package
-      Resources
-      Schedule
-      Service
-      Stage
-      Tidy
-      User
-      Whit
-    }.freeze
+    Component
+    Exec
+    File
+    Filebucket
+    Group
+    Node
+    Notify
+    Package
+    Resources
+    Schedule
+    Service
+    Stage
+    Tidy
+    User
+    Whit
+  }.freeze
 
   BUILTIN_TYPE_NAMES_LC = Set.new(BUILTIN_TYPE_NAMES.map { |n| n.downcase }).freeze
 
@@ -37,6 +37,7 @@ class StaticLoader < Loader
   }.freeze
 
   attr_reader :loaded
+
   def initialize
     @loaded = {}
     @runtime_3_initialized = false
@@ -45,7 +46,7 @@ class StaticLoader < Loader
 
   def discover(type, error_collector = nil, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
     # Static loader only contains runtime types
-    return EMPTY_ARRAY unless type == :type && name_authority == name_authority = Pcore::RUNTIME_NAME_AUTHORITY #rubocop:disable Lint/AssignmentInCondition
+    return EMPTY_ARRAY unless type == :type && name_authority == name_authority = Pcore::RUNTIME_NAME_AUTHORITY
 
     typed_names = type == :type && name_authority == Pcore::RUNTIME_NAME_AUTHORITY ? @loaded.keys : EMPTY_ARRAY
     block_given? ? typed_names.select { |tn| yield(tn) } : typed_names

data/lib/puppet/pops/loader/task_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The TypeDefinitionInstantiator instantiates a type alias or a type definition
 #
 require_relative '../../../puppet/module/task'

data/lib/puppet/pops/loader/type_definition_instantiator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # The TypeDefinitionInstantiator instantiates a type alias or a type definition
 #
 module Puppet::Pops
@@ -18,24 +19,24 @@ class TypeDefinitionInstantiator
       # ok
     else
       raise ArgumentError,
-        _("The code loaded from %{source_ref} must contain only the type '%{name}' - it has additional definitions.") % { source_ref: source_ref, name: name }
+            _("The code loaded from %{source_ref} must contain only the type '%{name}' - it has additional definitions.") % { source_ref: source_ref, name: name }
     end
     type_definition = model.definitions[0]
 
     unless type_definition.is_a?(Model::TypeAlias) || type_definition.is_a?(Model::TypeDefinition)
       raise ArgumentError,
-        _("The code loaded from %{source_ref} does not define the type '%{name}' - no type alias or type definition found.") % { source_ref: source_ref, name: name }
+            _("The code loaded from %{source_ref} does not define the type '%{name}' - no type alias or type definition found.") % { source_ref: source_ref, name: name }
     end
 
     actual_name = type_definition.name
     unless name == actual_name.downcase
       raise ArgumentError,
-        _("The code loaded from %{source_ref} produced type with the wrong name, expected '%{name}', actual '%{actual_name}'") % { source_ref: source_ref, name: name, actual_name: actual_name }
+            _("The code loaded from %{source_ref} produced type with the wrong name, expected '%{name}', actual '%{actual_name}'") % { source_ref: source_ref, name: name, actual_name: actual_name }
     end
 
     unless model.body == type_definition
       raise ArgumentError,
-        _("The code loaded from %{source_ref} contains additional logic - can only contain the type '%{name}'") % { source_ref: source_ref, name: name }
+            _("The code loaded from %{source_ref} contains additional logic - can only contain the type '%{name}'") % { source_ref: source_ref, name: name }
     end
 
     # Adapt the type definition with loader - this is used from logic contained in its body to find the
@@ -90,6 +91,7 @@ class TypeDefinitionInstantiator
   # @api private
   def self.named_definition(te)
     return 'Object' if te.is_a?(Model::LiteralHash)
+
     te.is_a?(Model::AccessExpression) && (left = te.left_expr).is_a?(Model::QualifiedReference) ? left.cased_value : nil
   end
 

data/lib/puppet/pops/loader/typed_name.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Loader
 # A namespace/name/type combination that can be used as a compound hash key

data/lib/puppet/pops/loader/uri_helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops::Loader::UriHelper
   # Raises an exception if specified gem can not be located
   #

data/lib/puppet/pops/loaders.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 # This is the container for all Loader instances. Each Loader instance has a `loader_name` by which it can be uniquely
 # identified within this container.
@@ -37,6 +38,7 @@ class Loaders
   def initialize(environment, for_agent, load_from_pcore = true)
     # Protect against environment havoc
     raise ArgumentError.new(_("Attempt to redefine already initialized loaders for environment")) unless environment.loaders.nil?
+
     environment.loaders = self
     @environment = environment
     @loaders_by_name = {}
@@ -180,6 +182,7 @@ class Loaders
   def self.loaders
     loaders = Puppet.lookup(:loaders) { nil }
     raise Puppet::ParseError, _("Internal Error: Puppet Context ':loaders' missing") if loaders.nil?
+
     loaders
   end
 
@@ -216,6 +219,7 @@ class Loaders
       if loader.nil?
         raise Puppet::ParseError, _("Internal Error: did not find public loader for module: '%{module_name}'") % { module_name: module_name }
       end
+
       loader
     end
   end
@@ -262,6 +266,7 @@ class Loaders
     if @loaders_by_name.include?(name)
       raise Puppet::ParseError, _("Internal Error: Attempt to redefine loader named '%{name}'") % { name: name }
     end
+
     @loaders_by_name[name] = loader
   end
 
@@ -281,22 +286,22 @@ class Loaders
     parser = Parser::EvaluatingParser.singleton
     parsed_code = Puppet[:code]
     program = if parsed_code != ""
-      parser.parse_string(parsed_code, 'unknown-source-location')
-    else
-      file = @environment.manifest
-
-      # if the manifest file is a reference to a directory, parse and combine
-      # all .pp files in that directory
-      if file == Puppet::Node::Environment::NO_MANIFEST
-        nil
-      elsif File.directory?(file)
-        raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints directory '#{file}'. It must be a file"
-      elsif File.exist?(file)
-        parser.parse_file(file)
-      else
-        raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints '#{file}'. It does not exist"
-      end
-    end
+                parser.parse_string(parsed_code, 'unknown-source-location')
+              else
+                file = @environment.manifest
+
+                # if the manifest file is a reference to a directory, parse and
+                # combine all .pp files in that directory
+                if file == Puppet::Node::Environment::NO_MANIFEST
+                  nil
+                elsif File.directory?(file)
+                  raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints directory '#{file}'. It must be a file"
+                elsif File.exist?(file)
+                  parser.parse_file(file)
+                else
+                  raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints '#{file}'. It does not exist"
+                end
+              end
     instantiate_definitions(program, public_environment_loader) unless program.nil?
     program
   rescue Puppet::ParseErrorWithIssue => detail
@@ -450,7 +455,6 @@ class Loaders
   #       what is available with a reasonable API.
   #
   class LoaderModuleData
-
     attr_accessor :public_loader
     attr_accessor :private_loader
     attr_accessor :resolutions
@@ -499,7 +503,6 @@ class Loaders
   # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
   #
   class ModuleResolver
-
     def initialize(loaders)
       @loaders = loaders
       @index = {}

data/lib/puppet/pops/lookup/configured_data_provider.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'hiera_config'
 require_relative 'data_provider'
 

data/lib/puppet/pops/lookup/context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'interpolation'
 
 module Puppet::Pops
@@ -134,29 +135,29 @@ class Context
     tf = Types::TypeFactory
     key_type = tf.optional(tf.scalar)
     @type = Pcore::create_object_type(loader, ir, self, 'Puppet::LookupContext', 'Any',
-      {
-        'environment_name' => {
-          Types::KEY_TYPE => Types::PStringType::NON_EMPTY,
-          Types::KEY_KIND => Types::PObjectType::ATTRIBUTE_KIND_DERIVED
-        },
-        'module_name' => {
-          Types::KEY_TYPE => tf.variant(Types::PStringType::NON_EMPTY, Types::PUndefType::DEFAULT)
-        }
-      },
-      {
-        'not_found' => tf.callable([0, 0], tf.undef),
-        'explain' => tf.callable([0, 0, tf.callable(0,0)], tf.undef),
-        'interpolate' => tf.callable(1, 1),
-        'cache' => tf.callable([key_type, tf.any], tf.any),
-        'cache_all' => tf.callable([tf.hash_kv(key_type, tf.any)], tf.undef),
-        'cache_has_key' => tf.callable([key_type], tf.boolean),
-        'cached_value' => tf.callable([key_type], tf.any),
-        'cached_entries' => tf.variant(
-          tf.callable([0, 0, tf.callable(1,1)], tf.undef),
-          tf.callable([0, 0, tf.callable(2,2)], tf.undef),
-          tf.callable([0, 0], tf.iterable(tf.tuple([key_type, tf.any])))),
-        'cached_file_data' => tf.callable(tf.string, tf.optional(tf.callable([1, 1])))
-      }
+                                      {
+                                        'environment_name' => {
+                                          Types::KEY_TYPE => Types::PStringType::NON_EMPTY,
+                                          Types::KEY_KIND => Types::PObjectType::ATTRIBUTE_KIND_DERIVED
+                                        },
+                                        'module_name' => {
+                                          Types::KEY_TYPE => tf.variant(Types::PStringType::NON_EMPTY, Types::PUndefType::DEFAULT)
+                                        }
+                                      },
+                                      {
+                                        'not_found' => tf.callable([0, 0], tf.undef),
+                                        'explain' => tf.callable([0, 0, tf.callable(0,0)], tf.undef),
+                                        'interpolate' => tf.callable(1, 1),
+                                        'cache' => tf.callable([key_type, tf.any], tf.any),
+                                        'cache_all' => tf.callable([tf.hash_kv(key_type, tf.any)], tf.undef),
+                                        'cache_has_key' => tf.callable([key_type], tf.boolean),
+                                        'cached_value' => tf.callable([key_type], tf.any),
+                                        'cached_entries' => tf.variant(
+                                          tf.callable([0, 0, tf.callable(1,1)], tf.undef),
+                                          tf.callable([0, 0, tf.callable(2,2)], tf.undef),
+                                          tf.callable([0, 0], tf.iterable(tf.tuple([key_type, tf.any])))),
+                                        'cached_file_data' => tf.callable(tf.string, tf.optional(tf.callable([1, 1])))
+                                      }
     ).resolve(loader)
   end
 

data/lib/puppet/pops/lookup/data_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Lookup
 # A class that adapts a Hash