puppet 4.2.0 → 4.3.0

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

@@ -0,0 +1,283 @@
+module Puppet::Plugins::DataProviders
+  module DataProvider
+    # 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)
+      lookup_invocation.with(:data_provider, self) do
+        hash = data(data_key(key, lookup_invocation), lookup_invocation)
+        value = hash[key]
+        if value || hash.include?(key)
+          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. This hook is used by the hiera style
+    # providers to perform interpolation. The default method simply returns the given _value_.
+    #
+    # @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)
+      value
+    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
+    protected :data_key
+
+    # 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
+    protected :validate_data
+  end
+
+  class ModuleDataProvider
+    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
+    protected :data_key
+
+    # Assert that all keys in the given _data_ are prefixed with the given _module_name_.
+    #
+    # @param data [Hash] The data hash
+    # @param module_name [String] The name of the module where the data was found
+    # @return [Hash] The data_hash unaltered
+    def validate_data(data, module_name)
+      module_prefix = "#{module_name}::"
+      data.each_key do |k|
+        unless k.is_a?(String) && (k == 'lookup_options' || k.start_with?(module_prefix))
+          raise Puppet::DataBinding::LookupError, "Module data for module '#{module_name}' must use keys qualified with the name of the module"
+        end
+      end
+    end
+    protected :validate_data
+  end
+
+  class EnvironmentDataProvider
+    include DataProvider
+
+    def data_key(key, lookup_invocation)
+      'environment'
+    end
+    protected :data_key
+  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
+    #
+    # @api public
+    def initialize(name, paths)
+      @name = name
+      @paths = paths
+    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)
+      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 = data(path.path, lookup_invocation)
+                value = hash[key]
+                if value || hash.include?(key)
+                  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
+    # @return [DataProvider] The created data provider
+    #
+    # @api public
+    def create(name, paths)
+      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
+  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/adapters.rb

@@ -85,6 +85,18 @@ module Puppet::Pops::Adapters
       locator.string.slice(offset, length)
     end
 
+    def extract_tree_text
+      first = @adapted.offset
+      last = first + @adapted.length
+      @adapted.eAllContents.each do |m|
+        m_offset = m.offset
+        first = m_offset if m_offset < first
+        m_last = m_offset + m.length
+        last = m_last if m_last > last
+      end
+      locator.string.slice(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

data/lib/puppet/pops/binder/binder.rb

@@ -138,7 +138,7 @@ class Puppet::Pops::Binder::Binder
 
   # @api private
   def self.format_binding(b)
-    type_name = Puppet::Pops::Types::TypeCalculator.new().string(b.type)
+    type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(b.type)
     layer_name, bindings_name = get_named_binding_layer_and_name(b)
     "binding: '#{type_name}/#{b.name}' in: '#{bindings_name}' in layer: '#{layer_name}'"
   end
@@ -319,7 +319,7 @@ class Puppet::Pops::Binder::Binder
           unless key_factory.is_contributions_key?(k)
             if v.is_abstract?()
               layer_name, bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(v.binding)
-              type_name = key_factory.type_calculator.string(v.binding.type)
+              type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(v.binding.type)
               raise ArgumentError, "The abstract binding '#{type_name}/#{v.binding.name}' in '#{bindings_name}' in layer '#{layer_name}' was not overridden"
             end
             raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry

data/lib/puppet/pops/binder/bindings_checker.rb

@@ -12,7 +12,7 @@ class Puppet::Pops::Binder::BindingsChecker
   # @api public
   def initialize(diagnostics_producer)
     @@check_visitor     ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
-    @type_calculator      = Puppet::Pops::Types::TypeCalculator.new()
+    @type_calculator      = Puppet::Pops::Types::TypeCalculator.singleton
     @expression_validator = Puppet::Pops::Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
     @acceptor             = diagnostics_producer
   end

data/lib/puppet/pops/binder/bindings_label_provider.rb

@@ -1,7 +1,9 @@
 # A provider of labels for bindings model object, producing a human name for the model object.
 # @api private
 #
-class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
+class Puppet::Pops::Binder::BindingsLabelProvider
+  include Puppet::Pops::LabelProvider
+
   def initialize
     @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
   end

data/lib/puppet/pops/binder/bindings_loader.rb

@@ -38,11 +38,10 @@ class Puppet::Pops::Binder::BindingsLoader
     paths_for_name(name).find {|p| Puppet::FileSystem.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
   end
 
-  private
-
   def self.loader()
     @autoloader ||= Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings")
   end
+  private_class_method :loader
 
   def self.provide_from_string(scope, name)
     name_path = name.split('::')
@@ -52,6 +51,7 @@ class Puppet::Pops::Binder::BindingsLoader
     end
     provide_from_name_path(scope, name, name_path)
   end
+  private_class_method :provide_from_string
 
   def self.provide_from_name_path(scope, name, name_path)
     # If bindings is already loaded, try this first
@@ -64,14 +64,17 @@ class Puppet::Pops::Binder::BindingsLoader
     end
     result
   end
+  private_class_method :provide_from_name_path
 
   def self.paths_for_name(fq_name)
     [de_camel(fq_name), downcased_path(fq_name)].uniq
   end
+  private_class_method :paths_for_name
 
   def self.downcased_path(fq_name)
     fq_name.to_s.gsub(/::/, '/').downcase
   end
+  private_class_method :downcased_path
 
   def self.de_camel(fq_name)
     fq_name.to_s.gsub(/::/, '/').
@@ -80,4 +83,5 @@ class Puppet::Pops::Binder::BindingsLoader
     tr("-", "_").
     downcase
   end
+  private_class_method :de_camel
 end

data/lib/puppet/pops/binder/bindings_model_meta.rb

@@ -94,7 +94,7 @@ module Puppet::Pops::Binder::Bindings
   # @api public
   #
   class LookupProducerDescriptor < ProducerDescriptor
-    contains_one_uni 'type', Puppet::Pops::Types::PAnyType
+    has_attr 'type', Object
     has_attr 'name', String
   end
 
@@ -147,7 +147,7 @@ module Puppet::Pops::Binder::Bindings
   #
   # @api public
   class Binding < AbstractBinding
-    contains_one_uni 'type', Puppet::Pops::Types::PAnyType
+    has_attr 'type', Object
     has_attr 'name', String
     has_attr 'override', Boolean
     has_attr 'abstract', Boolean

data/lib/puppet/pops/binder/config/binder_config.rb

@@ -23,7 +23,7 @@ module Puppet::Pops::Binder::Config
 
     DEFAULT_LAYERS = [
       { 'name' => 'site',    'include' => [ 'confdir:/default?optional'] },
-      { 'name' => 'modules', 'include' => [ 'module:/*::default'] },
+      { 'name' => 'modules', 'include' => [ 'module:/*::default', 'module:/*::metadata'] },
     ]
 
     DEFAULT_SCHEME_EXTENSIONS = {}

data/lib/puppet/pops/binder/injector.rb

@@ -354,7 +354,7 @@ module Private
     def initialize
       @entries = []
       @key_factory = Puppet::Pops::Binder::KeyFactory.new()
-      @type_calculator = @key_factory.type_calculator
+      @type_calculator = Puppet::Pops::Types::TypeCalculator.singleton
     end
 
     def lookup(scope, *args, &block)
@@ -430,7 +430,7 @@ module Private
       # represented the same (but still opaque) way.
       #
       @key_factory         = configured_binder.key_factory()
-      @type_calculator     = key_factory.type_calculator()
+      @type_calculator     = Puppet::Pops::Types::TypeCalculator.singleton
       @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform", 2,  2)
       @recursion_lock = [ ]
     end
@@ -484,7 +484,7 @@ module Private
     def lookup_type(scope, type, name='')
       val = lookup_key(scope, named_key(type, name))
       return nil if val.nil?
-      unless key_factory.type_calculator.instance?(type, val)
+      unless type_calculator.instance?(type, val)
         raise ArgumentError, "Type error: incompatible type, #{type_error_detail(type, val)}"
       end
       val
@@ -510,7 +510,7 @@ module Private
         when Puppet::Pops::Binder::InjectorEntry
           val = produce(scope, entry)
           return nil if val.nil?
-          unless key_factory.type_calculator.instance?(entry.binding.type, val)
+          unless type_calculator.instance?(entry.binding.type, val)
             raise "Type error: incompatible type returned by producer, #{type_error_detail(entry.binding.type, val)}"
           end
           val

data/lib/puppet/pops/binder/key_factory.rb

@@ -3,12 +3,6 @@
 #
 class Puppet::Pops::Binder::KeyFactory
 
-  attr_reader :type_calculator
-  # @api public
-  def initialize(type_calculator = Puppet::Pops::Types::TypeCalculator.new())
-    @type_calculator = type_calculator
-  end
-
   # @api public
   def binding_key(binding)
     named_key(binding.type, binding.name)
@@ -16,12 +10,12 @@ class Puppet::Pops::Binder::KeyFactory
 
   # @api public
   def named_key(type, name)
-    [(@type_calculator.assignable?(@type_calculator.data, type) ? @type_calculator.data : type), name]
+    [(Puppet::Pops::Types::PDataType::DEFAULT.assignable?(type) ? Puppet::Pops::Types::PDataType::DEFAULT : type), name]
   end
 
   # @api public
   def data_key(name)
-    [@type_calculator.data, name]
+    [Puppet::Pops::Types::PDataType::DEFAULT, name]
   end
 
   # @api public
@@ -49,7 +43,7 @@ class Puppet::Pops::Binder::KeyFactory
   # @api public
   def is_data?(key)
     return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PAnyType)
-    type_calculator.assignable?(type_calculator.data(), key[0])
+    Puppet::Pops::Types::PDataType::DEFAULT.assignable?(key[0])
   end
 
   # @api public