puppet 4.10.0 → 5.0.0

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

@@ -1,4 +1,3 @@
-require 'hiera/scope'
 require_relative 'configured_data_provider'
 
 module Puppet::Pops
@@ -12,19 +11,17 @@ class GlobalDataProvider < ConfiguredDataProvider
   def unchecked_key_lookup(key, lookup_invocation, merge)
     config = config(lookup_invocation)
     if(config.version == 3)
+      require 'hiera/scope'
       # Hiera version 3 needs access to special scope variables
       scope = lookup_invocation.scope
       unless scope.is_a?(Hiera::Scope)
-        hiera_invocation = Invocation.new(
-          Hiera::Scope.new(scope),
-          lookup_invocation.override_values,
-          lookup_invocation.default_values,
-          lookup_invocation.explainer)
+        return lookup_invocation.with_scope(Hiera::Scope.new(scope)) do |hiera_invocation|
 
-        # Confine to global scope unless an environment data provider has been defined (same as for hiera_xxx functions)
-        adapter = lookup_invocation.lookup_adapter
-        hiera_invocation.set_global_only unless adapter.global_only? || adapter.has_environment_data_provider?(lookup_invocation)
-        lookup_invocation = hiera_invocation
+          # Confine to global scope unless an environment data provider has been defined (same as for hiera_xxx functions)
+          adapter = lookup_invocation.lookup_adapter
+          hiera_invocation.set_global_only unless adapter.global_only? || adapter.has_environment_data_provider?(lookup_invocation)
+          hiera_invocation.lookup(key, lookup_invocation.module_name) { unchecked_key_lookup(key , hiera_invocation, merge) }
+        end
       end
 
       merge = MergeStrategy.strategy(merge)

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

@@ -81,8 +81,8 @@ class HieraConfig
 
   def self.v4_function_config(config_root, function_name, owner)
     unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'legacy_provider_function',
-        "Using of legacy data provider function '#{function_name}'. Please convert to a 'data_hash' function")
+      Puppet.warn_once('deprecations', 'legacy_provider_function',
+        _("Using of legacy data provider function '%{function_name}'. Please convert to a 'data_hash' function") % { function_name: function_name })
     end
     HieraConfigV5.new(config_root, nil,
       {
@@ -106,7 +106,9 @@ class HieraConfig
   def self.symkeys_to_string(struct)
     case(struct)
     when Hash
-      Hash[struct.map { |k,v| [k.to_s, symkeys_to_string(v)] }]
+      map = {}
+      struct.each_pair {|k,v| map[ k.is_a?(Symbol) ? k.to_s : k] = symkeys_to_string(v) }
+      map
     when Array
       struct.map { |v| symkeys_to_string(v) }
     else
@@ -137,7 +139,7 @@ class HieraConfig
           if parsed.is_a?(Hash)
             parsed
           else
-            Puppet.warning("#{config_path}: File exists but does not contain a valid YAML hash. Falling back to Hiera version 3 default config")
+            Puppet.warning(_("%{config_path}: File exists but does not contain a valid YAML hash. Falling back to Hiera version 3 default config") % { config_path: config_path })
             HieraConfigV3::DEFAULT_CONFIG_HASH
           end
         end
@@ -195,7 +197,7 @@ class HieraConfig
   def configured_data_providers(lookup_invocation, parent_data_provider, use_default_hierarchy = false)
     unless @data_providers && scope_interpolations_stable?(lookup_invocation)
       if @data_providers
-        lookup_invocation.report_text { 'Hiera configuration recreated due to change of scope variables used in interpolation expressions' }
+        lookup_invocation.report_text { _('Hiera configuration recreated due to change of scope variables used in interpolation expressions') }
       end
       slc_invocation = ScopeLookupCollectingInvocation.new(lookup_invocation.scope)
       begin
@@ -421,8 +423,8 @@ class HieraConfigV3 < HieraConfig
 
   def validate_config(config, owner)
     unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'hiera.yaml',
-        "#{@config_path}: Use of 'hiera.yaml' version 3 is deprecated. It should be converted to version 5", config_path.to_s)
+      Puppet.warn_once('deprecations', 'hiera.yaml',
+        _("%{config_path}: Use of 'hiera.yaml' version 3 is deprecated. It should be converted to version 5") % { config_path: @config_path }, config_path.to_s)
     end
     config[KEY_VERSION] ||= 3
     config[KEY_BACKENDS] ||= DEFAULT_CONFIG_HASH[KEY_BACKENDS]
@@ -469,10 +471,6 @@ end
 
 # @api private
 class HieraConfigV4 < HieraConfig
-  require 'puppet/plugins/data_providers'
-
-  include Puppet::Plugins::DataProviders
-
   def self.config_type
     return @@CONFIG_TYPE if class_variable_defined?(:@@CONFIG_TYPE)
     tf = Types::TypeFactory
@@ -491,25 +489,6 @@ class HieraConfigV4 < HieraConfig
     })
   end
 
-  def factory_create_data_provider(lookup_invocation, name, parent_data_provider, provider_name, datadir, original_paths)
-    service_type = Registry.hash_of_path_based_data_provider_factories
-    provider_factory = Puppet.lookup(:injector).lookup(nil, service_type, PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)[provider_name]
-    unless provider_factory
-      fail(Issues::HIERA_NO_PROVIDER_FOR_BACKEND, { :name => provider_name }, find_line_matching(/[^\w]#{provider_name}(?:[^\w]|$)/))
-    end
-
-    paths = original_paths.map { |path| interpolate(path, lookup_invocation, false) }
-    paths = provider_factory.resolve_paths(datadir, original_paths, paths, lookup_invocation)
-
-    provider_factory_version = provider_factory.respond_to?(:version) ? provider_factory.version : 1
-    if provider_factory_version == 1
-      # Version 1 is not aware of the parent provider
-      provider_factory.create(name, paths)
-    else
-      provider_factory.create(name, paths, parent_data_provider)
-    end
-  end
-
   def create_configured_data_providers(lookup_invocation, parent_data_provider, _)
     default_datadir = @config[KEY_DATADIR]
     data_providers = {}
@@ -536,7 +515,7 @@ class HieraConfigV4 < HieraConfig
         create_data_provider(name, parent_data_provider, KEY_DATA_HASH, 'hocon_data', {},
           resolve_paths(datadir, original_paths, lookup_invocation, @config_path.nil?, '.conf'))
       else
-        factory_create_data_provider(lookup_invocation, name, parent_data_provider, provider_name, datadir, original_paths)
+        fail(Issues::HIERA_NO_PROVIDER_FOR_BACKEND, { :name => provider_name }, find_line_matching(/[^\w]#{provider_name}(?:[^\w]|$)/))
       end
     end
     data_providers.values
@@ -544,8 +523,8 @@ class HieraConfigV4 < HieraConfig
 
   def validate_config(config, owner)
     unless Puppet[:strict] == :off
-      Puppet.warn_once(:deprecation, 'hiera.yaml',
-        "#{@config_path}: Use of 'hiera.yaml' version 4 is deprecated. It should be converted to version 5", config_path.to_s)
+      Puppet.warn_once('deprecations', 'hiera.yaml',
+        _("%{config_path}: Use of 'hiera.yaml' version 4 is deprecated. It should be converted to version 5") % { config_path: @config_path }, config_path.to_s)
     end
     config[KEY_DATADIR] ||= 'data'
     config[KEY_HIERARCHY] ||= [{ KEY_NAME => 'common', KEY_BACKEND => 'yaml' }]
@@ -606,7 +585,7 @@ class HieraConfigV5 < HieraConfig
 
   def create_configured_data_providers(lookup_invocation, parent_data_provider, use_default_hierarchy)
     defaults = @config[KEY_DEFAULTS] || EMPTY_HASH
-    datadir = defaults[KEY_DATADIR] || 'data'
+    datadir = defaults[KEY_DATADIR] || _('data')
 
     # Hashes enumerate their values in the order that the corresponding keys were inserted so it's safe to use
     # a hash for the data_providers.

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

@@ -1,3 +1,4 @@
+require 'hiera/scope'
 require_relative 'sub_lookup'
 module Puppet::Pops
 module Lookup
@@ -57,10 +58,11 @@ module Interpolation
           # Alias is only permitted if the entire string is equal to the interpolate expression
           fail(Issues::HIERA_INTERPOLATION_ALIAS_NOT_ENTIRE_STRING) if is_alias && subject != match
           value = interpolate_method(method_key).call(key, lookup_invocation, subject)
-          value = lookup_invocation.check(method_key == :scope ? "scope:#{key}" : key) { interpolate(value, lookup_invocation, allow_methods) }
 
           # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
           return value if is_alias
+
+          value = lookup_invocation.check(method_key == :scope ? "scope:#{key}" : key) { interpolate(value, lookup_invocation, allow_methods) }
         end
         value.nil? ? '' : value
       end
@@ -70,15 +72,14 @@ module Interpolation
   def interpolate_method(method_key)
     @@interpolate_methods ||= begin
       global_lookup = lambda do |key, lookup_invocation, _|
-        if lookup_invocation.scope.is_a?(Hiera::Scope) && !lookup_invocation.global_only?
+        scope = lookup_invocation.scope
+        if scope.is_a?(Hiera::Scope) && !lookup_invocation.global_only?
           # "unwrap" the Hiera::Scope
-          lookup_invocation = Invocation.new(
-            lookup_invocation.scope.real,
-            lookup_invocation.override_values,
-            lookup_invocation.default_values,
-            lookup_invocation.explainer)
+          scope = scope.real
+        end
+        lookup_invocation.with_scope(scope) do |sub_invocation|
+          sub_invocation.lookup(key) {  Lookup.lookup(key, nil, '', true, nil, sub_invocation) }
         end
-        Lookup.lookup(key, nil, '', true, nil, lookup_invocation)
       end
       scope_lookup = lambda do |key, lookup_invocation, subject|
         segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }

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

@@ -10,6 +10,15 @@ class Invocation
     @current
   end
 
+  # Creates a new instance with same settings as this instance but with a new given scope
+  # and yields with that scope.
+  #
+  # @param scope [Puppet::Parser::Scope] The new scope
+  # @return [Invocation] the new instance
+  def with_scope(scope)
+    yield(Invocation.new(scope, override_values, default_values, explainer))
+  end
+
   # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
   # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
   # about the progress of the lookup.
@@ -53,9 +62,10 @@ class Invocation
     @explainer = explainer
   end
 
-  def lookup(key, module_name)
+  def lookup(key, module_name = nil)
+    key = LookupKey.new(key) unless key.is_a?(LookupKey)
     @top_key = key
-    @module_name = module_name
+    @module_name = module_name.nil? ? key.module_name : module_name
     save_current = self.class.current
     if save_current.equal?(self)
       yield
@@ -71,7 +81,7 @@ class Invocation
 
   def check(name)
     if @name_stack.include?(name)
-      raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@name_stack.join(', ')}]"
+      raise Puppet::DataBinding::RecursiveLookupError, _("Recursive lookup detected in [%{name_stack}]") % { name_stack: @name_stack.join(', ') }
     end
     return unless block_given?
 

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

@@ -90,7 +90,7 @@ class LookupAdapter < DataAdapter
     end
   rescue Puppet::DataBinding::LookupError => detail
     raise detail unless detail.issue_code.nil?
-    error = Puppet::Error.new("Lookup of key '#{lookup_invocation.top_key}' failed: #{detail.message}")
+    error = Puppet::Error.new(_("Lookup of key '%{key}' failed: %{detail}") % { key: lookup_invocation.top_key, detail: detail.message })
     error.set_backtrace(detail.backtrace)
     raise error
   end
@@ -236,18 +236,18 @@ class LookupAdapter < DataAdapter
   PROVIDER_STACK = [:lookup_global, :lookup_in_environment, :lookup_in_module].freeze
 
   def validate_lookup_options(options, module_name)
-    raise Puppet::DataBinding::LookupError.new("value of #{LOOKUP_OPTIONS} must be a hash") unless options.is_a?(Hash) unless options.nil?
+    raise Puppet::DataBinding::LookupError.new(_("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS }) unless options.is_a?(Hash) unless options.nil?
     return options if module_name.nil?
 
     pfx = "#{module_name}::"
     options.each_pair do |key, value|
       if key.start_with?(LOOKUP_OPTIONS_PATTERN_START)
         unless key[1..pfx.length] == pfx
-          raise Puppet::DataBinding::LookupError.new("all #{LOOKUP_OPTIONS} patterns must match a key starting with module name '#{module_name}'")
+          raise Puppet::DataBinding::LookupError.new(_("all %{opts} patterns must match a key starting with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
         end
       else
         unless key.start_with?(pfx)
-          raise Puppet::DataBinding::LookupError.new("all #{LOOKUP_OPTIONS} keys must start with module name '#{module_name}'")
+          raise Puppet::DataBinding::LookupError.new(_("all %{opts} keys must start with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
         end
       end
     end
@@ -289,13 +289,17 @@ class LookupAdapter < DataAdapter
           compile_patterns(global_lookup_options(meta_invocation, merge_strategy))
         else
           opts = env_lookup_options(meta_invocation, merge_strategy)
-          catch(:no_such_key) do
-            module_opts = validate_lookup_options(lookup_in_module(LookupKey::LOOKUP_OPTIONS, meta_invocation, merge_strategy), module_name)
-            opts = if opts.nil?
-              module_opts
-            else
-              merge_strategy.lookup([GLOBAL_ENV_MERGE, "Module #{lookup_invocation.module_name}"], meta_invocation) do |n|
-                meta_invocation.with(:scope, n) { meta_invocation.report_found(LOOKUP_OPTIONS,  n == GLOBAL_ENV_MERGE ? opts : module_opts) }
+          unless module_name.nil?
+            # Store environment options at key nil. This removes the need for an additional lookup for keys that are not prefixed.
+            @lookup_options[nil] = compile_patterns(opts) unless @lookup_options.include?(nil)
+            catch(:no_such_key) do
+              module_opts = validate_lookup_options(lookup_in_module(LookupKey::LOOKUP_OPTIONS, meta_invocation, merge_strategy), module_name)
+              opts = if opts.nil?
+                module_opts
+              else
+                merge_strategy.lookup([GLOBAL_ENV_MERGE, "Module #{lookup_invocation.module_name}"], meta_invocation) do |n|
+                  meta_invocation.with(:scope, n) { meta_invocation.report_found(LOOKUP_OPTIONS,  n == GLOBAL_ENV_MERGE ? opts : module_opts) }
+                end
               end
             end
           end
@@ -356,29 +360,19 @@ class LookupAdapter < DataAdapter
     return nil if mod.nil?
 
     metadata = mod.metadata
-    binding = false
     provider_name = metadata.nil? ? nil : metadata['data_provider']
-    if provider_name.nil?
-      provider_name = bound_module_provider_name(module_name)
-      binding = !provider_name.nil?
-    end
 
     mp = nil
     if mod.has_hiera_conf?
       mp = ModuleDataProvider.new(module_name)
-      # A version 5 hiera.yaml trumps a data provider setting or binding in the module
+      # A version 5 hiera.yaml trumps a data provider setting in the module
       mp_config = mp.config(lookup_invocation)
       if mp_config.nil?
         mp = nil
       elsif mp_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
-          if binding
-            Puppet.warn_once(:deprecation, "ModuleBinding#data_provider-#{module_name}",
-              "Defining data_provider '#{provider_name}' as a Puppet::Binding is deprecated. The binding is ignored since a '#{HieraConfig::CONFIG_FILE_NAME}' with version >= 5 is present")
-          else
-            Puppet.warn_once(:deprecation, "metadata.json#data_provider-#{module_name}",
-              "Defining \"data_provider\": \"#{provider_name}\" in metadata.json is deprecated. It is ignored since a '#{HieraConfig::CONFIG_FILE_NAME}' with version >= 5 is present", mod.metadata_file)
-          end
+          Puppet.warn_once('deprecations', "metadata.json#data_provider-#{module_name}",
+            _("Defining \"data_provider\": \"%{name}\" in metadata.json is deprecated. It is ignored since a '%{config}' with version >= 5 is present") % { name: provider_name, config: HieraConfig::CONFIG_FILE_NAME }, mod.metadata_file)
         end
         provider_name = nil
       end
@@ -388,15 +382,9 @@ class LookupAdapter < DataAdapter
       mp
     else
       unless Puppet[:strict] == :off
-        if binding
-          msg = "Defining data_provider '#{provider_name}' as a Puppet::Binding is deprecated"
-          msg += ". A '#{HieraConfig::CONFIG_FILE_NAME}' file should be used instead" if mp.nil?
-          Puppet.warn_once(:deprecation, "ModuleBinding#data_provider-#{module_name}", msg)
-        else
-          msg = "Defining \"data_provider\": \"#{provider_name}\" in metadata.json is deprecated"
-          msg += ". A '#{HieraConfig::CONFIG_FILE_NAME}' file should be used instead" if mp.nil?
-          Puppet.warn_once(:deprecation, "metadata.json#data_provider-#{module_name}", msg, mod.metadata_file)
-        end
+        msg = _("Defining \"data_provider\": \"%{name}\" in metadata.json is deprecated") % { name: provider_name }
+        msg += _(". A '%{config}' file should be used instead") % { config: HieraConfig::CONFIG_FILE_NAME } if mp.nil?
+        Puppet.warn_once('deprecations', "metadata.json#data_provider-#{module_name}", msg, mod.metadata_file)
       end
 
       case provider_name
@@ -409,26 +397,11 @@ class LookupAdapter < DataAdapter
         mp.config = HieraConfig.v4_function_config(Pathname(mod.path), "#{module_name}::data", mp)
         mp
       else
-        injector = Puppet.lookup(:injector) { nil }
-        provider = injector.lookup(nil,
-          Puppet::Plugins::DataProviders::Registry.hash_of_module_data_providers,
-          Puppet::Plugins::DataProviders::MODULE_DATA_PROVIDERS_KEY)[provider_name]
-        unless provider
-          raise Puppet::Error.new("Environment '#{environment.name}', cannot find module_data_provider '#{provider_name}'")
-        end
-        # Provider is configured per module but cached using compiler life cycle so it must be cloned
-        provider.clone
+        raise Puppet::Error.new(_("Environment '%{env}', cannot find module_data_provider '%{provider}'")) % { env: environment.name, provider: provider_name }
       end
     end
   end
 
-  def bound_module_provider_name(module_name)
-    injector = Puppet.lookup(:injector) { nil }
-    injector.nil? ? nil : injector.lookup(nil,
-      Puppet::Plugins::DataProviders::Registry.hash_of_per_module_data_provider,
-      Puppet::Plugins::DataProviders::PER_MODULE_DATA_PROVIDER_KEY)[module_name]
-  end
-
   def initialize_env_provider(lookup_invocation)
     env_conf = environment.configuration
     return nil if env_conf.nil? || env_conf.path_to_env.nil?
@@ -447,12 +420,12 @@ class LookupAdapter < DataAdapter
         ep = nil
       elsif ep_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
-          Puppet.warn_once(:deprecation, 'environment.conf#data_provider',
-            "Defining environment_data_provider='#{provider_name}' in environment.conf is deprecated", env_path + 'environment.conf')
+          Puppet.warn_once('deprecations', 'environment.conf#data_provider',
+            _("Defining environment_data_provider='%{provider_name}' in environment.conf is deprecated") % { provider_name: provider_name }, env_path + 'environment.conf')
 
           unless provider_name == 'hiera'
-            Puppet.warn_once(:deprecation, 'environment.conf#data_provider_overridden',
-              "The environment_data_provider='#{provider_name}' setting is ignored since '#{config_path}' version >= 5", env_path + 'environment.conf')
+            Puppet.warn_once('deprecations', 'environment.conf#data_provider_overridden',
+              _("The environment_data_provider='%{provider_name}' setting is ignored since '%{config_path}' version >= 5") % { provider_name: provider_name, config_path: config_path }, env_path + 'environment.conf')
           end
         end
         provider_name = nil
@@ -463,9 +436,9 @@ class LookupAdapter < DataAdapter
       ep
     else
       unless Puppet[:strict] == :off
-        msg = "Defining environment_data_provider='#{provider_name}' in environment.conf is deprecated"
-        msg += ". A '#{HieraConfig::CONFIG_FILE_NAME}' file should be used instead" if ep.nil?
-        Puppet.warn_once(:deprecation, 'environment.conf#data_provider', msg, env_path + 'environment.conf')
+        msg = _("Defining environment_data_provider='%{provider_name}' in environment.conf is deprecated") % { provider_name: provider_name }
+        msg += _(". A '%{config}' file should be used instead") % { config: HieraConfig::CONFIG_FILE_NAME } if ep.nil?
+        Puppet.warn_once('deprecations', 'environment.conf#data_provider', msg, env_path + 'environment.conf')
       end
 
       case provider_name
@@ -479,19 +452,7 @@ class LookupAdapter < DataAdapter
         ep.config = HieraConfigV5.v4_function_config(env_path, 'environment::data', ep)
         ep
       else
-         injector = Puppet.lookup(:injector) { nil }
-
-        # Support running tests without an injector being configured == using a null implementation
-        return nil unless injector
-
-        # Get the service (registry of known implementations)
-        provider = injector.lookup(nil,
-          Puppet::Plugins::DataProviders::Registry.hash_of_environment_data_providers,
-          Puppet::Plugins::DataProviders::ENV_DATA_PROVIDERS_KEY)[provider_name]
-        unless provider
-          raise Puppet::Error.new("Environment '#{environment.name}', cannot find environment_data_provider '#{provider_name}'")
-        end
-        provider
+        raise Puppet::Error.new(_("Environment '%{env}', cannot find environment_data_provider '%{provider}'") % { env: environment.name, provider: provider_name })
       end
     end
   end

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

@@ -9,14 +9,14 @@ class LookupKey
   attr_reader :module_name, :root_key, :segments
 
   def initialize(key)
-    segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in key: '#{key}'") }
+    segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new(_("%{problem} in key: '%{key}'") % { problem: problem, key: key }) }
     root_key = segments.shift.freeze
     qual_index = root_key.index(DOUBLE_COLON)
 
     @key = key
     @module_name = qual_index.nil? ? nil : root_key[0..qual_index-1].freeze
     @root_key = root_key
-    @segments = segments.empty? ? nil : segments.map { |segment| segment =~ /^[0-9]+$/ ? segment.to_i : segment }.freeze
+    @segments = segments.empty? ? nil : segments.freeze
   end
 
   def dig(lookup_invocation, value)

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

@@ -60,8 +60,16 @@ class ModuleDataProvider < ConfiguredDataProvider
   protected
 
   def assert_config_version(config)
-    config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'module') unless config.version > 3
-    config
+    if config.version > 3
+      config
+    else
+      if Puppet[:strict] == :error
+        config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'module')
+      else
+        Puppet.warn_once(:hiera_v3_at_module_root, config.config_path, _('hiera.yaml version 3 found at module root was ignored'), config.config_path)
+      end
+      nil
+    end
   end
 
   # Return the root of the module with the name equal to the configured module name
@@ -73,7 +81,7 @@ class ModuleDataProvider < ConfiguredDataProvider
   def provider_root(lookup_invocation)
     env = lookup_invocation.scope.environment
     mod = env.module(module_name)
-    raise Puppet::DataBinding::LookupError, "Environment '#{env.name}', cannot find module '#{module_name}'" unless mod
+    raise Puppet::DataBinding::LookupError, _("Environment '%{env}', cannot find module '%{module_name}'") % { env: env.name, module_name: module_name } unless mod
     Pathname.new(mod.path)
   end
 end

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

@@ -30,7 +30,13 @@ module SubLookup
       raise yield('Syntax error') unless segments.size * 2 == count + 1
       segments.map! do |segment|
         segment.strip!
-        segment.start_with?('"') || segment.start_with?("'") ? segment[1..-2] : segment
+        if segment.start_with?('"') || segment.start_with?("'")
+          segment[1..-2]
+        elsif segment =~ /^(:?[+-]?[0-9]+)$/
+          segment.to_i
+        else
+          segment
+        end
       end
     else
       raise yield('Syntax error')
@@ -58,20 +64,16 @@ module SubLookup
             lookup_invocation.report_not_found(segment)
             throw :no_such_key
           end
-          if segment.is_a?(Integer) || segment =~ /^[0-9]+$/
-            segment = segment.to_i
-            unless value.instance_of?(Array)
-              raise Puppet::DataBinding::LookupError,
-                "Data Provider type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}' from key '#{key}'"
-            end
-            unless segment < value.size
+          if segment.is_a?(Integer) && value.instance_of?(Array)
+            unless segment >= 0 && segment < value.size
               lookup_invocation.report_not_found(segment)
               throw :no_such_key
             end
           else
-            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
+            unless value.respond_to?(:'[]') && !(value.is_a?(Array) || value.instance_of?(String))
               raise Puppet::DataBinding::LookupError,
-                "Data Provider type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}' from key '#{key}'"
+                _("Data Provider type mismatch: Got %{klass} when a hash-like object was expected to access value using '%{segment}' from key '%{key}'") %
+                  { klass: value.class.name, segment: segment, key: key }
             end
             unless value.include?(segment)
               lookup_invocation.report_not_found(segment)

data/lib/puppet/pops/lookup.rb

@@ -28,7 +28,7 @@ module Lookup
     override_values = lookup_invocation.override_values
     result_with_name = names.reduce([nil, not_found]) do |memo, key|
       value = override_values.include?(key) ? assert_type(["Value found for key '%s' in override hash", key], value_type, override_values[key]) : not_found
-      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge) } if value.equal?(not_found)
+      catch(:no_such_key) { value = search_and_merge(key, lookup_invocation, merge, false) } if value.equal?(not_found)
       break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
       memo
     end
@@ -72,9 +72,9 @@ module Lookup
   end
 
   # @api private
-  def self.search_and_merge(name, lookup_invocation, merge)
+  def self.search_and_merge(name, lookup_invocation, merge, apl = true)
     answer = lookup_invocation.lookup_adapter.lookup(name, lookup_invocation, merge)
-    lookup_invocation.emit_debug_info("Automatic Parameter Lookup of '#{name}") if Puppet[:debug]
+    lookup_invocation.emit_debug_info("Automatic Parameter Lookup of '#{name}'") if apl && Puppet[:debug]
     answer
   end
 
@@ -84,8 +84,10 @@ module Lookup
   private_class_method :assert_type
 
   def self.fail_lookup(names)
-    name_part = names.size == 1 ? "the name '#{names[0]}'" : 'any of the names [' + names.map { |n| "'#{n}'" }.join(', ') + ']'
-    raise Puppet::DataBinding::LookupError, "Function lookup() did not find a value for #{name_part}"
+    raise Puppet::DataBinding::LookupError,
+          n_("Function lookup() did not find a value for the name '%{name}'",
+             "Function lookup() did not find a value for any of the names [%{name_list}]", names.size
+            ) % { name: names[0], name_list: names.map { |n| "'#{n}'" }.join(', ') }
   end
   private_class_method :fail_lookup
 end

data/lib/puppet/pops/merge_strategy.rb

@@ -120,7 +120,7 @@ module Puppet::Pops
       when 0
         throw :no_such_key
       when 1
-        yield(lookup_variants[0])
+        merge_single(yield(lookup_variants[0]))
       else
         lookup_invocation.with(:merge, self) do
           result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
@@ -149,6 +149,13 @@ module Puppet::Pops
       value
     end
 
+    # Applies the merge strategy on a single element. Only applicable for `unique`
+    # @param value [Object] the value to merge with nothing
+    # @return [Object] the merged value
+    def merge_single(value)
+      value
+    end
+
     def options
       @options
     end
@@ -282,6 +289,14 @@ module Puppet::Pops
       e.is_a?(Array) ? e.flatten : [e]
     end
 
+    # If _value_ is an array, then return the result of calling `uniq` on that array. Otherwise,
+    # the argument is returned.
+    # @param value [Object] the value to merge with nothing
+    # @return [Object] the merged value
+    def merge_single(value)
+      value.is_a?(Array) ? value.uniq : value
+    end
+
     protected
 
     def value_t