puppet 8.3.1-x64-mingw32 → 8.5.0-x64-mingw32

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.
 #
@@ -9,7 +9,7 @@ class PredefinedLoader < BaseLoader
     nil
   end
 
-  def to_s()
+  def to_s
     "(PredefinedLoader '#{loader_name}')"
   end
 
@@ -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,9 @@ 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,9 @@ 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.
@@ -39,10 +40,10 @@ class PuppetResourceTypeImplInstantiator
       if s.is_a?(Model::CallMethodExpression)
         functor_expr = s.functor_expr
         functor_expr.is_a?(Model::NamedAccessExpression) &&
-          functor_expr.left_expr.is_a?(Model::QualifiedReference) &&
-          functor_expr.left_expr.cased_value == rname &&
-          functor_expr.right_expr.is_a?(Model::QualifiedName) &&
-          functor_expr.right_expr.value == 'new'
+        functor_expr.left_expr.is_a?(Model::QualifiedReference) &&
+        functor_expr.left_expr.cased_value == rname &&
+        functor_expr.right_expr.is_a?(Model::QualifiedName) &&
+        functor_expr.right_expr.value == 'new'
       else
         false
       end
@@ -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,16 +39,18 @@ 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] }
+        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]
+        }
       end
     end
 
@@ -72,14 +75,16 @@ 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
-    ripped.each {|x| walk(x, source_ref, result) }
+    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
   private_class_method :assert_code
 
   def self.walk(x, source_ref, result)
     return unless x.is_a?(Array)
+
     first = x[0]
     case first
     when :fcall, :call
@@ -97,12 +102,12 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
         url: "https://puppet.com/docs/puppet/latest/functions_refactor_legacy.html"
       }
     end
-    x.each {|v| walk(v, source_ref, result) }
+    x.each { |v| walk(v, source_ref, result) }
   end
   private_class_method :walk
 
   def self.find_identity(rast)
-    rast.find{|x| x.is_a?(Array) && x[0] == :@ident }
+    rast.find { |x| x.is_a?(Array) && x[0] == :@ident }
   end
   private_class_method :find_identity
 
@@ -115,7 +120,7 @@ class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
   # Returns an Array; a tuple with method name and line number or "<unknown>" if either is missing, or format is not the expected
   #
   def self.extract_name_line(x)
-    (x.is_a?(Array) ? [ x[1], x[2].is_a?(Array) ? x[2][1] : nil] : [nil, nil]).map {|v| v.nil? ? UNKNOWN : v }
+    (x.is_a?(Array) ? [x[1], x[2].is_a?(Array) ? x[2][1] : nil] : [nil, nil]).map { |v| v.nil? ? UNKNOWN : v }
   end
   private_class_method :extract_name_line
 end

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
@@ -21,7 +21,7 @@ class Runtime3TypeLoader < BaseLoader
     parent.discover(type, error_collector, name_authority, &block)
   end
 
-  def to_s()
+  def to_s
     "(Runtime3TypeLoader '#{loader_name()}')"
   end
 
@@ -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
@@ -14,8 +14,7 @@ class Puppet::Pops::Loader::SimpleEnvironmentLoader < Puppet::Pops::Loader::Base
     nil
   end
 
-  def to_s()
+  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
@@ -72,7 +73,7 @@ class StaticLoader < Loader
     nil # at top of the hierarchy
   end
 
-  def to_s()
+  def to_s
     "(StaticLoader)"
   end
 
@@ -107,7 +108,7 @@ class StaticLoader < Loader
     end
   end
 
-  def create_resource_type_references()
+  def create_resource_type_references
     # These needs to be done quickly and we do not want to scan the file system for these
     # We are also not interested in their definition only that they exist.
     # These types are in all environments.

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'
@@ -35,8 +36,8 @@ class TaskInstantiator
   end
 
   def self.convert_types(args)
-    args.each_with_object({}) do |(k, v), hsh|
-      hsh[k] = v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
+    args.transform_values do |v|
+      v['type'].nil? ? Types::TypeFactory.data : Types::TypeParser.singleton.parse(v['type'])
     end if args
   end
   private_class_method :convert_types

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
@@ -52,7 +53,8 @@ class TypeDefinitionInstantiator
     loader.set_entry(
       typed_name,
       type,
-      type_definition.locator.to_uri(type_definition))
+      type_definition.locator.to_uri(type_definition)
+    )
     type
   end
 
@@ -90,6 +92,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
@@ -20,7 +21,7 @@ class TypedName
     parts = name.to_s.split(DOUBLE_COLON)
     if parts[0].empty?
       parts.shift
-      @name = name[2..-1]
+      @name = name[2..]
     else
       @name = name
     end

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

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Puppet::Pops::Loader::UriHelper
   # Raises an exception if specified gem can not be located
   #
-  def path_for_uri(uri, subdir='lib')
+  def path_for_uri(uri, subdir = 'lib')
     case uri.scheme
     when "gem"
       begin

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
@@ -360,11 +365,11 @@ class Loaders
     nil
   end
 
-  def create_puppet_system_loader()
+  def create_puppet_system_loader
     Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
-  def create_puppet_cache_loader()
+  def create_puppet_cache_loader
     Loader::ModuleLoaders.cached_loader_from(puppet_system_loader, self)
   end
 
@@ -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 = {}
@@ -515,7 +518,7 @@ class Loaders
     end
 
     def all_module_loaders
-      @all_module_loaders ||= @index.values.map {|md| md.public_loader }
+      @all_module_loaders ||= @index.values.map { |md| md.public_loader }
     end
 
     def resolve(module_data)

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
@@ -133,31 +134,38 @@ class Context
   def self.register_ptype(loader, ir)
     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
+    @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)
+          }
         },
-        '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])))
         }
-      },
-      {
-        '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)
+      ).resolve(loader)
   end
 
   # Mainly for test purposes. Makes it possible to create a {Context} in Puppet code provided that a current {Invocation} exists.

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