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

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'data_dig_function_provider'
 require_relative 'data_hash_function_provider'
 require_relative 'lookup_key_function_provider'
@@ -6,7 +7,6 @@ require_relative 'location_resolver'
 
 module Puppet::Pops
 module Lookup
-
 # @api private
 class ScopeLookupCollectingInvocation < Invocation
   def initialize(scope)
@@ -84,20 +84,19 @@ class HieraConfig
   def self.v4_function_config(config_root, function_name, owner)
     unless Puppet[:strict] == :off
       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 })
+                       _("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,
-      {
-        KEY_VERSION => 5,
-        KEY_HIERARCHY => [
-          {
-            KEY_NAME => "Legacy function '#{function_name}'",
-            KEY_V4_DATA_HASH => function_name
-          }
-        ]
-      }.freeze,
-      owner
-    )
+                      {
+                        KEY_VERSION => 5,
+                        KEY_HIERARCHY => [
+                          {
+                            KEY_NAME => "Legacy function '#{function_name}'",
+                            KEY_V4_DATA_HASH => function_name
+                          }
+                        ]
+                      }.freeze,
+                      owner)
   end
 
   def self.config_exist?(config_root)
@@ -106,10 +105,10 @@ class HieraConfig
   end
 
   def self.symkeys_to_string(struct)
-    case(struct)
+    case (struct)
     when Hash
       map = {}
-      struct.each_pair {|k,v| map[ k.is_a?(Symbol) ? k.to_s : k] = symkeys_to_string(v) }
+      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) }
@@ -163,7 +162,8 @@ class HieraConfig
     else
       issue = Issues::HIERA_UNSUPPORTED_VERSION
       raise Puppet::DataBinding::LookupError.new(
-        issue.format(:version => version),  config_path, nil, nil, nil, issue.issue_code)
+        issue.format(:version => version), config_path, nil, nil, nil, issue.issue_code
+      )
     end
   end
 
@@ -184,7 +184,8 @@ class HieraConfig
 
   def fail(issue, args = EMPTY_HASH, line = nil)
     raise Puppet::DataBinding::LookupError.new(
-      issue.format(args.merge(:label => self)),  @config_path, line, nil, nil, issue.issue_code)
+      issue.format(args.merge(:label => self)), @config_path, line, nil, nil, issue.issue_code
+    )
   end
 
   def has_default_hierarchy?
@@ -227,16 +228,18 @@ class HieraConfig
     File.foreach(@config_path) do |line|
       line_number += 1
       next if line_number < start_line
+
       quote = nil
       stripped = ''.dup
       line.each_codepoint do |cp|
-        if cp == 0x22 || cp == 0x27 # double or single quote
+        case cp
+        when 0x22, 0x27 # double or single quote
           if quote == cp
             quote = nil
           elsif quote.nil?
             quote = cp
           end
-        elsif cp == 0x23 # unquoted hash mark
+        when 0x23 # unquoted hash mark
           break
         end
         stripped << cp
@@ -295,19 +298,17 @@ class HieraConfig
           hiera3_config[key] = val
         end
       end
+    elsif hiera3_config.include?(KEY_LOGGER)
+      Hiera.logger = hiera3_config[KEY_LOGGER].to_s
     else
-      if hiera3_config.include?(KEY_LOGGER)
-        Hiera.logger = hiera3_config[KEY_LOGGER].to_s
-      else
-        Hiera.logger = 'puppet'
-      end
+      Hiera.logger = 'puppet'
     end
 
     unless Hiera::Interpolate.const_defined?(:PATCHED_BY_HIERA_5)
       # Replace the class methods 'hiera_interpolate' and 'alias_interpolate' with a method that wires back and performs global
       # lookups using the lookup framework. This is necessary since the classic Hiera is made aware only of custom backends.
       class << Hiera::Interpolate
-        hiera_interpolate = Proc.new do |data, key, scope, extra_data, context|
+        hiera_interpolate = Proc.new do |_data, key, scope, _extra_data, context|
           override = context[:order_override]
           invocation = Puppet::Pops::Lookup::Invocation.current
           unless override.nil? && invocation.global_only?
@@ -353,12 +354,13 @@ class HieraConfigV3 < HieraConfig
 
   def self.config_type
     return @@CONFIG_TYPE if class_variable_defined?(:@@CONFIG_TYPE)
+
     tf = Types::TypeFactory
     nes_t = Types::PStringType::NON_EMPTY
 
     # This is a hash, not a type. Contained backends are added prior to validation
     @@CONFIG_TYPE = {
-      tf.optional(KEY_VERSION) => tf.range(3,3),
+      tf.optional(KEY_VERSION) => tf.range(3, 3),
       tf.optional(KEY_BACKENDS) => tf.variant(nes_t, tf.array_of(nes_t)),
       tf.optional(KEY_LOGGER) => nes_t,
       tf.optional(KEY_MERGE_BEHAVIOR) => tf.enum('deep', 'deeper', 'native'),
@@ -374,7 +376,8 @@ class HieraConfigV3 < HieraConfig
         Hiera::Scope.new(scope),
         lookup_invocation.override_values,
         lookup_invocation.default_values,
-        lookup_invocation.explainer)
+        lookup_invocation.explainer
+      )
     end
 
     default_datadir = File.join(Puppet.settings[:codedir], 'environments', '%{::environment}', 'hieradata')
@@ -405,21 +408,29 @@ class HieraConfigV3 < HieraConfig
         ext = ".#{ext}"
       end
       paths = resolve_paths(datadir, original_paths, lookup_invocation, @config_path.nil?, ext)
-      data_providers[backend] = case
-      when backend == 'json', backend == 'yaml'
-        create_data_provider(backend, parent_data_provider, KEY_V3_DATA_HASH, "#{backend}_data", { KEY_DATADIR => datadir }, paths)
-      when backend == 'hocon' && Puppet.features.hocon?
-        create_data_provider(backend, parent_data_provider, KEY_V3_DATA_HASH, 'hocon_data', { KEY_DATADIR => datadir }, paths)
-      when backend == 'eyaml' && Puppet.features.hiera_eyaml?
-        create_data_provider(backend, parent_data_provider, KEY_V3_LOOKUP_KEY, 'eyaml_lookup_key', backend_config.merge(KEY_DATADIR => datadir), paths)
-      else
-        create_hiera3_backend_provider(backend, backend, parent_data_provider, datadir, paths, @loaded_config)
-      end
+      data_providers[backend] =
+        if %w[json yaml].include? backend
+          create_data_provider(backend, parent_data_provider, KEY_V3_DATA_HASH,
+                               "#{backend}_data", { KEY_DATADIR => datadir },
+                               paths)
+        elsif backend == 'hocon' && Puppet.features.hocon?
+          create_data_provider(backend, parent_data_provider, KEY_V3_DATA_HASH,
+                               'hocon_data', { KEY_DATADIR => datadir }, paths)
+        elsif backend == 'eyaml' && Puppet.features.hiera_eyaml?
+          create_data_provider(backend, parent_data_provider,
+                               KEY_V3_LOOKUP_KEY, 'eyaml_lookup_key',
+                               backend_config.merge(KEY_DATADIR => datadir),
+                               paths)
+        else
+          create_hiera3_backend_provider(backend, backend,
+                                         parent_data_provider, datadir, paths,
+                                         @loaded_config)
+        end
     end
     data_providers.values
   end
 
-  DEFAULT_CONFIG_HASH =  {
+  DEFAULT_CONFIG_HASH = {
     KEY_BACKENDS => %w(yaml),
     KEY_HIERARCHY => %w(nodes/%{::trusted.certname} common),
     KEY_MERGE_BEHAVIOR => 'native'
@@ -428,7 +439,7 @@ class HieraConfigV3 < HieraConfig
   def validate_config(config, owner)
     unless Puppet[:strict] == :off
       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)
+                       _("%{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]
@@ -436,7 +447,7 @@ class HieraConfigV3 < HieraConfig
     config[KEY_MERGE_BEHAVIOR] ||= DEFAULT_CONFIG_HASH[KEY_MERGE_BEHAVIOR]
     config[KEY_DEEP_MERGE_OPTIONS] ||= {}
 
-    backends = [ config[KEY_BACKENDS] ].flatten
+    backends = [config[KEY_BACKENDS]].flatten
 
     # Create the final struct used for validation (backends are included as keys to arbitrary configs in the form of a hash)
     tf = Types::TypeFactory
@@ -477,20 +488,22 @@ end
 class HieraConfigV4 < HieraConfig
   def self.config_type
     return @@CONFIG_TYPE if class_variable_defined?(:@@CONFIG_TYPE)
+
     tf = Types::TypeFactory
     nes_t = Types::PStringType::NON_EMPTY
 
-    @@CONFIG_TYPE = tf.struct({
-      KEY_VERSION => tf.range(4, 4),
-      tf.optional(KEY_DATADIR) => nes_t,
-      tf.optional(KEY_HIERARCHY) => tf.array_of(tf.struct(
-        KEY_BACKEND => nes_t,
-        KEY_NAME => nes_t,
-        tf.optional(KEY_DATADIR) => nes_t,
-        tf.optional(KEY_PATH) => nes_t,
-        tf.optional(KEY_PATHS) => tf.array_of(nes_t)
-      ))
-    })
+    @@CONFIG_TYPE =
+      tf.struct({
+                  KEY_VERSION => tf.range(4, 4),
+                  tf.optional(KEY_DATADIR) => nes_t,
+                  tf.optional(KEY_HIERARCHY) => tf.array_of(tf.struct(
+                                                              KEY_BACKEND => nes_t,
+                                                              KEY_NAME => nes_t,
+                                                              tf.optional(KEY_DATADIR) => nes_t,
+                                                              tf.optional(KEY_PATH) => nes_t,
+                                                              tf.optional(KEY_PATHS) => tf.array_of(nes_t)
+                                                            ))
+                })
   end
 
   def create_configured_data_providers(lookup_invocation, parent_data_provider, _)
@@ -511,16 +524,28 @@ class HieraConfigV4 < HieraConfig
       original_paths = he[KEY_PATHS] || [he[KEY_PATH] || name]
       datadir = @config_root + (he[KEY_DATADIR] || default_datadir)
       provider_name = he[KEY_BACKEND]
-      data_providers[name] = case
-      when provider_name == 'json', provider_name == 'yaml'
-        create_data_provider(name, parent_data_provider, KEY_DATA_HASH, "#{provider_name}_data", {},
-          resolve_paths(datadir, original_paths, lookup_invocation, @config_path.nil?, ".#{provider_name}"))
-      when provider_name == 'hocon' &&  Puppet.features.hocon?
-        create_data_provider(name, parent_data_provider, KEY_DATA_HASH, 'hocon_data', {},
-          resolve_paths(datadir, original_paths, lookup_invocation, @config_path.nil?, '.conf'))
-      else
-        fail(Issues::HIERA_NO_PROVIDER_FOR_BACKEND, { :name => provider_name }, find_line_matching(/[^\w]#{provider_name}(?:[^\w]|$)/))
-      end
+      data_providers[name] =
+        if %w[json yaml].include?(provider_name)
+          create_data_provider(name, parent_data_provider, KEY_DATA_HASH,
+                               "#{provider_name}_data", {},
+                               resolve_paths(datadir,
+                                             original_paths,
+                                             lookup_invocation,
+                                             @config_path.nil?,
+                                             ".#{provider_name}"))
+        elsif provider_name == 'hocon' && Puppet.features.hocon?
+          create_data_provider(name, parent_data_provider, KEY_DATA_HASH,
+                               'hocon_data', {},
+                               resolve_paths(datadir,
+                                             original_paths,
+                                             lookup_invocation,
+                                             @config_path.nil?,
+                                             '.conf'))
+        else
+          fail(Issues::HIERA_NO_PROVIDER_FOR_BACKEND,
+               { :name => provider_name },
+               find_line_matching(/[^\w]#{provider_name}(?:[^\w]|$)/))
+        end
     end
     data_providers.values
   end
@@ -528,7 +553,7 @@ class HieraConfigV4 < HieraConfig
   def validate_config(config, owner)
     unless Puppet[:strict] == :off
       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)
+                       _("%{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' }]
@@ -544,6 +569,7 @@ end
 class HieraConfigV5 < HieraConfig
   def self.config_type
     return @@CONFIG_TYPE if class_variable_defined?(:@@CONFIG_TYPE_V5)
+
     tf = Types::TypeFactory
     nes_t = Types::PStringType::NON_EMPTY
 
@@ -553,39 +579,43 @@ class HieraConfigV5 < HieraConfig
     # The option name must start with a letter and end with a letter or digit. May contain underscore and dash.
     option_name_t = tf.pattern(/\A[A-Za-z](:?[0-9A-Za-z_-]*[0-9A-Za-z])?\z/)
 
-    hierarchy_t = tf.array_of(tf.struct(
-      {
-        KEY_NAME => nes_t,
-        tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
-        tf.optional(KEY_DATA_HASH) => nes_t,
-        tf.optional(KEY_LOOKUP_KEY) => nes_t,
-        tf.optional(KEY_V3_BACKEND) => nes_t,
-        tf.optional(KEY_V4_DATA_HASH) => nes_t,
-        tf.optional(KEY_DATA_DIG) => nes_t,
-        tf.optional(KEY_PATH) => nes_t,
-        tf.optional(KEY_PATHS) => tf.array_of(nes_t, tf.range(1, :default)),
-        tf.optional(KEY_GLOB) => nes_t,
-        tf.optional(KEY_GLOBS) => tf.array_of(nes_t, tf.range(1, :default)),
-        tf.optional(KEY_URI) => uri_t,
-        tf.optional(KEY_URIS) => tf.array_of(uri_t, tf.range(1, :default)),
-        tf.optional(KEY_MAPPED_PATHS) => tf.array_of(nes_t, tf.range(3, 3)),
-        tf.optional(KEY_DATADIR) => nes_t
-      }))
-
-    @@CONFIG_TYPE = tf.struct({
-      KEY_VERSION => tf.range(5, 5),
-      tf.optional(KEY_DEFAULTS) => tf.struct(
-        {
-          tf.optional(KEY_DATA_HASH) => nes_t,
-          tf.optional(KEY_LOOKUP_KEY) => nes_t,
-          tf.optional(KEY_DATA_DIG) => nes_t,
-          tf.optional(KEY_DATADIR) => nes_t,
-          tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
-        }),
-      tf.optional(KEY_HIERARCHY) => hierarchy_t,
-      tf.optional(KEY_PLAN_HIERARCHY) => hierarchy_t,
-      tf.optional(KEY_DEFAULT_HIERARCHY) => hierarchy_t
-    })
+    hierarchy_t =
+      tf.array_of(tf.struct(
+                    {
+                      KEY_NAME => nes_t,
+                      tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
+                      tf.optional(KEY_DATA_HASH) => nes_t,
+                      tf.optional(KEY_LOOKUP_KEY) => nes_t,
+                      tf.optional(KEY_V3_BACKEND) => nes_t,
+                      tf.optional(KEY_V4_DATA_HASH) => nes_t,
+                      tf.optional(KEY_DATA_DIG) => nes_t,
+                      tf.optional(KEY_PATH) => nes_t,
+                      tf.optional(KEY_PATHS) => tf.array_of(nes_t, tf.range(1, :default)),
+                      tf.optional(KEY_GLOB) => nes_t,
+                      tf.optional(KEY_GLOBS) => tf.array_of(nes_t, tf.range(1, :default)),
+                      tf.optional(KEY_URI) => uri_t,
+                      tf.optional(KEY_URIS) => tf.array_of(uri_t, tf.range(1, :default)),
+                      tf.optional(KEY_MAPPED_PATHS) => tf.array_of(nes_t, tf.range(3, 3)),
+                      tf.optional(KEY_DATADIR) => nes_t
+                    }
+                  ))
+
+    @@CONFIG_TYPE =
+      tf.struct({
+                  KEY_VERSION => tf.range(5, 5),
+                  tf.optional(KEY_DEFAULTS) => tf.struct(
+                    {
+                      tf.optional(KEY_DATA_HASH) => nes_t,
+                      tf.optional(KEY_LOOKUP_KEY) => nes_t,
+                      tf.optional(KEY_DATA_DIG) => nes_t,
+                      tf.optional(KEY_DATADIR) => nes_t,
+                      tf.optional(KEY_OPTIONS) => tf.hash_kv(option_name_t, tf.data),
+                    }
+                  ),
+                  tf.optional(KEY_HIERARCHY) => hierarchy_t,
+                  tf.optional(KEY_PLAN_HIERARCHY) => hierarchy_t,
+                  tf.optional(KEY_DEFAULT_HIERARCHY) => hierarchy_t
+                })
   end
 
   def create_configured_data_providers(lookup_invocation, parent_data_provider, use_default_hierarchy)
@@ -606,12 +636,12 @@ class HieraConfigV5 < HieraConfig
 
     compiler = Puppet.lookup(:pal_compiler) { nil }
     config_key = if compiler.is_a?(Puppet::Pal::ScriptCompiler) && !@config[KEY_PLAN_HIERARCHY].nil?
-          KEY_PLAN_HIERARCHY
-        elsif use_default_hierarchy
-          KEY_DEFAULT_HIERARCHY
-        else
-          KEY_HIERARCHY
-        end
+                   KEY_PLAN_HIERARCHY
+                 elsif use_default_hierarchy
+                   KEY_DEFAULT_HIERARCHY
+                 else
+                   KEY_HIERARCHY
+                 end
     @config[config_key].each do |he|
       name = he[KEY_NAME]
       if data_providers.include?(name)
@@ -656,21 +686,28 @@ class HieraConfigV5 < HieraConfig
                     end
       end
       next if @config_path.nil? && !locations.nil? && locations.empty? # Default config and no existing paths found
+
       options = he[KEY_OPTIONS] || defaults[KEY_OPTIONS]
       options = options.nil? ? EMPTY_HASH : interpolate(options, lookup_invocation, false)
-      if(function_kind == KEY_V3_BACKEND)
+      if (function_kind == KEY_V3_BACKEND)
         v3options = { :datadir => entry_datadir.to_s }
         options.each_pair { |k, v| v3options[k.to_sym] = v }
-        data_providers[name] = create_hiera3_backend_provider(name, function_name, parent_data_provider, entry_datadir, locations, {
-          :hierarchy =>
-            locations.nil? ? [] : locations.map do |loc|
-              path = loc.original_location
-              path.end_with?(".#{function_name}") ? path[0..-(function_name.length + 2)] : path
-            end,
-          function_name.to_sym => v3options,
-          :backends => [ function_name ],
-          :logger => 'puppet'
-        })
+        data_providers[name] =
+          create_hiera3_backend_provider(name,
+                                         function_name,
+                                         parent_data_provider,
+                                         entry_datadir,
+                                         locations,
+                                         {
+                                           :hierarchy =>
+                                             locations.nil? ? [] : locations.map do |loc|
+                                               path = loc.original_location
+                                               path.end_with?(".#{function_name}") ? path[0..-(function_name.length + 2)] : path
+                                             end,
+                                           function_name.to_sym => v3options,
+                                           :backends => [function_name],
+                                           :logger => 'puppet'
+                                         })
       else
         data_providers[name] = create_data_provider(name, parent_data_provider, function_kind, function_name, options, locations)
       end
@@ -714,6 +751,7 @@ class HieraConfigV5 < HieraConfig
       unless owner.is_a?(ModuleDataProvider)
         fail(Issues::HIERA_DEFAULT_HIERARCHY_NOT_IN_MODULE, EMPTY_HASH, find_line_matching(/(?:^|\s+)#{KEY_DEFAULT_HIERARCHY}:/))
       end
+
       config[KEY_DEFAULT_HIERARCHY].each { |he| validate_hierarchy(he, defaults, owner) }
     end
     config
@@ -737,10 +775,11 @@ class HieraConfigV5 < HieraConfig
       unless owner.is_a?(GlobalDataProvider)
         fail(Issues::HIERA_V3_BACKEND_NOT_GLOBAL, EMPTY_HASH, find_line_matching(/\s+#{KEY_V3_BACKEND}:/))
       end
-      if v3_backend == 'json' || v3_backend == 'yaml' || v3_backend == 'hocon' &&  Puppet.features.hocon?
+
+      if v3_backend == 'json' || v3_backend == 'yaml' || v3_backend == 'hocon' && Puppet.features.hocon?
         # Disallow use of backends that have corresponding "data_hash" functions in version 5
         fail(Issues::HIERA_V3_BACKEND_REPLACED_BY_DATA_HASH, { :function_name => v3_backend },
-          find_line_matching(/\s+#{KEY_V3_BACKEND}:\s*['"]?#{v3_backend}(?:[^\w]|$)/))
+             find_line_matching(/\s+#{KEY_V3_BACKEND}:\s*['"]?#{v3_backend}(?:[^\w]|$)/))
       end
     end
 

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'hiera/scope'
 require_relative 'sub_lookup'
 module Puppet::Pops
@@ -58,6 +59,7 @@ 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)
 
           # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
@@ -79,7 +81,7 @@ module Interpolation
           scope = scope.real
         end
         lookup_invocation.with_scope(scope) do |sub_invocation|
-          sub_invocation.lookup(key) {  Lookup.lookup(key, nil, '', true, nil, sub_invocation) }
+          sub_invocation.lookup(key) { Lookup.lookup(key, nil, '', true, nil, sub_invocation) }
         end
       end
       scope_lookup = lambda do |key, lookup_invocation, subject|
@@ -92,7 +94,7 @@ module Interpolation
           else
             scope = lookup_invocation.scope
             val = nil
-            if (default_key_exists = lookup_invocation.default_values.include?(root_key) )
+            if (default_key_exists = lookup_invocation.default_values.include?(root_key))
               catch(:undefined_variable) { val = scope[root_key] }
             else
               val = scope[root_key]
@@ -123,11 +125,12 @@ module Interpolation
         :hiera => global_lookup, # this is just an alias for 'lookup'
         :alias => global_lookup, # same as 'lookup' but expression must be entire string and result is not subject to string substitution
         :scope => scope_lookup,
-        :literal => lambda { |key, _, _| key }
+        :literal => ->(key, _, _) { key }
       }.freeze
     end
     interpolate_method = @@interpolate_methods[method_key]
     fail(Issues::HIERA_INTERPOLATION_UNKNOWN_INTERPOLATION_METHOD, :name => method_key) unless interpolate_method
+
     interpolate_method
   end
 
@@ -144,6 +147,7 @@ module Interpolation
     match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
     if match
       fail(Issues::HIERA_INTERPOLATION_METHOD_SYNTAX_NOT_ALLOWED) unless allow_methods
+
       key = match[1].to_sym
       data = match[2] || match[3] # double or single qouted
     else
@@ -154,7 +158,8 @@ module Interpolation
 
   def fail(issue, args = EMPTY_HASH)
     raise Puppet::DataBinding::LookupError.new(
-      issue.format(args), nil, nil, nil, nil, issue.issue_code)
+      issue.format(args), nil, nil, nil, nil, issue.issue_code
+    )
   end
 end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/thread_local'
 
 require_relative 'explainer'
@@ -109,9 +110,11 @@ class Invocation
     @explainer.emit_debug_info(preamble) if @explainer.is_a?(DebugExplainer)
   end
 
+  # rubocop:disable Naming/MemoizedInstanceVariableName
   def lookup_adapter
     @adapter ||= @adapter_class.adapt(scope.compiler)
   end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 
   # This method is overridden by the special Invocation used while resolving interpolations in a
   # Hiera configuration file (hiera.yaml) where it's used for collecting and remembering the current

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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
+
 # This class defines the private API of the Lookup Key Recorder support.
 # @api private
 #
 class Puppet::Pops::Lookup::KeyRecorder
-
-  def initialize()
+  def initialize
   end
 
+  # rubocop:disable Naming/MemoizedInstanceVariableName
   def self.singleton
     @null_recorder ||= self.new
   end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 
   # Records a key
   # (This implementation does nothing)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'pathname'
 require_relative 'interpolation'
 
@@ -90,7 +91,7 @@ module Lookup
         mapped_vars.map do |var|
           # Need to use parent lookup invocation to avoid adding 'var' to the set of variables to track for changes. The
           # variable that 'var' stems from is added above.
-          path = scope.with_local_scope(var_key => var) {  datadir + interpolate(template, lookup_invocation, false) }
+          path = scope.with_local_scope(var_key => var) { datadir + interpolate(template, lookup_invocation, false) }
           ResolvedLocation.new(template, path, path.exist?)
         end
       end