openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'hiera/scope'
 require_relative 'sub_lookup'
 module Puppet::Pops
@@ -46,8 +48,8 @@ module Interpolation
   def interpolate_string(subject, context, allow_methods)
     lookup_invocation = context.is_a?(Invocation) ? context : context.invocation
     lookup_invocation.with(:interpolate, subject) do
-      subject.gsub(/%\{([^\}]*)\}/) do |match|
-        expr = $1
+      subject.gsub(/%\{([^}]*)\}/) do |match|
+        expr = ::Regexp.last_match(1)
         # Leading and trailing spaces inside an interpolation expression are insignificant
         expr.strip!
         value = nil
@@ -57,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
@@ -78,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|
@@ -90,11 +93,16 @@ module Interpolation
             lookup_invocation.report_found_in_overrides(root_key, ovr[root_key])
           else
             scope = lookup_invocation.scope
-            val = scope[root_key]
+            val = nil
+            if (default_key_exists = lookup_invocation.default_values.include?(root_key))
+              catch(:undefined_variable) { val = scope[root_key] }
+            else
+              val = scope[root_key]
+            end
             if val.nil? && !nil_in_scope?(scope, root_key)
-              defaults = lookup_invocation.default_values
-              if defaults.include?(root_key)
-                lookup_invocation.report_found_in_defaults(root_key, defaults[root_key])
+              if default_key_exists
+                lookup_invocation.report_found_in_defaults(root_key,
+                                                           lookup_invocation.default_values[root_key])
               else
                 nil
               end
@@ -117,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
 
@@ -135,9 +144,10 @@ module Interpolation
   end
 
   def get_method_and_data(data, allow_methods)
-    match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
+    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
@@ -148,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,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/thread_local'
 
 require_relative 'explainer'
@@ -108,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,14 +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
+    @null_recorder ||= new
   end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 
   # Records a key
   # (This implementation does nothing)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require_relative 'interpolation'
 
@@ -41,7 +43,7 @@ module Lookup
     def expand_globs(datadir, declared_globs, lookup_invocation)
       declared_globs.map do |declared_glob|
         glob = datadir + interpolate(declared_glob, lookup_invocation, false)
-        Pathname.glob(glob).reject { |path| path.directory? }.map { |path| ResolvedLocation.new(glob.to_s, path, true) }
+        Pathname.glob(glob).reject(&:directory?).map { |path| ResolvedLocation.new(glob.to_s, path, true) }
       end.flatten
     end
 
@@ -89,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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'data_adapter'
 require_relative 'lookup_key'
 
@@ -9,15 +11,14 @@ module Lookup
 #
 # @api private
 class LookupAdapter < DataAdapter
-
   LOOKUP_OPTIONS_PREFIX = LOOKUP_OPTIONS + '.'
   LOOKUP_OPTIONS_PREFIX.freeze
-  LOOKUP_OPTIONS_PATTERN_START = '^'.freeze
+  LOOKUP_OPTIONS_PATTERN_START = '^'
 
-  HASH = 'hash'.freeze
-  MERGE = 'merge'.freeze
-  CONVERT_TO = 'convert_to'.freeze
-  NEW = 'new'.freeze
+  HASH = 'hash'
+  MERGE = 'merge'
+  CONVERT_TO = 'convert_to'
+  NEW = 'new'
 
   def self.create_adapter(compiler)
     new(compiler)
@@ -105,19 +106,19 @@ class LookupAdapter < DataAdapter
         convert_to[0] = Puppet::Pops::Types::TypeParser.singleton.parse(convert_to[0])
       rescue StandardError => e
         raise Puppet::DataBinding::LookupError,
-          _("Invalid data type in lookup_options for key '%{key}' could not parse '%{source}', error: '%{msg}") %
-            { key: key, source: convert_to[0], msg: e.message}
+              _("Invalid data type in lookup_options for key '%{key}' could not parse '%{source}', error: '%{msg}") %
+              { key: key, source: convert_to[0], msg: e.message }
       end
     end
     begin
-      result = lookup_invocation.scope.call_function(NEW, [convert_to[0], result, *convert_to[1..-1]])
+      result = lookup_invocation.scope.call_function(NEW, [convert_to[0], result, *convert_to[1..]])
       # TRANSLATORS 'lookup_options', 'convert_to' and args_string variable should not be translated,
       args_string = Puppet::Pops::Types::StringConverter.singleton.convert(convert_to)
       lookup_invocation.report_text { _("Applying convert_to lookup_option with arguments %{args}") % { args: args_string } }
     rescue StandardError => e
       raise Puppet::DataBinding::LookupError,
-        _("The convert_to lookup_option for key '%{key}' raised error: %{msg}") %
-          { key: key, msg: e.message}
+            _("The convert_to lookup_option for key '%{key}' raised error: %{msg}") %
+            { key: key, msg: e.message }
     end
     result
   end
@@ -138,7 +139,7 @@ class LookupAdapter < DataAdapter
       lookup_invocation.with(:global, terminus) do
         catch(:no_such_key) do
           return lookup_invocation.report_found(key, Puppet::DataBinding.indirection.find(key.root_key,
-            {:environment => environment, :variables => lookup_invocation.scope, :merge => merge_strategy}))
+                                                                                          { :environment => environment, :variables => lookup_invocation.scope, :merge => merge_strategy }))
         end
         lookup_invocation.report_not_found(key)
         throw :no_such_key
@@ -146,6 +147,7 @@ class LookupAdapter < DataAdapter
     end
   rescue Puppet::DataBinding::LookupError => detail
     raise detail unless detail.issue_code.nil?
+
     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
@@ -194,9 +196,11 @@ class LookupAdapter < DataAdapter
             opts = nil
             lookup_invocation.with(:scope, "Searching for \"#{LookupKey::LOOKUP_OPTIONS}\"") do
               catch(:no_such_key) do
-              opts = compile_patterns(
-                validate_lookup_options(
-                  provider.key_lookup_in_default(LookupKey::LOOKUP_OPTIONS, meta_invocation, MergeStrategy.strategy(HASH)), k))
+                opts = compile_patterns(
+                  validate_lookup_options(
+                    provider.key_lookup_in_default(LookupKey::LOOKUP_OPTIONS, meta_invocation, MergeStrategy.strategy(HASH)), k
+                  )
+                )
               end
             end
             @module_default_lookup_options[k] = opts
@@ -293,18 +297,18 @@ class LookupAdapter < DataAdapter
 
   def validate_lookup_options(options, module_name)
     return nil if options.nil?
-    raise Puppet::DataBinding::LookupError.new(_("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS }) unless options.is_a?(Hash)
+    raise Puppet::DataBinding::LookupError, _("value of %{opts} must be a hash") % { opts: LOOKUP_OPTIONS } unless options.is_a?(Hash)
     return options if module_name.nil?
 
     pfx = "#{module_name}::"
-    options.each_pair do |key, value|
+    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 %{opts} patterns must match a key starting with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
+          raise Puppet::DataBinding::LookupError, _("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 %{opts} keys must start with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name })
+          raise Puppet::DataBinding::LookupError, _("all %{opts} keys must start with module name '%{module_name}'") % { opts: LOOKUP_OPTIONS, module_name: module_name }
         end
       end
     end
@@ -312,6 +316,7 @@ class LookupAdapter < DataAdapter
 
   def compile_patterns(options)
     return nil if options.nil?
+
     key_options = {}
     pattern_options = {}
     options.each_pair do |key, value|
@@ -330,11 +335,11 @@ class LookupAdapter < DataAdapter
     else
       merge_strategy = Puppet::Pops::MergeStrategy.strategy(merge)
       key.dig(lookup_invocation,
-        merge_strategy.lookup(PROVIDER_STACK, lookup_invocation) { |m| send(m, key, lookup_invocation, merge_strategy) })
+              merge_strategy.lookup(PROVIDER_STACK, lookup_invocation) { |m| send(m, key, lookup_invocation, merge_strategy) })
     end
   end
 
-  GLOBAL_ENV_MERGE = 'Global and Environment'.freeze
+  GLOBAL_ENV_MERGE = 'Global and Environment'
 
   # Retrieve lookup options that applies when using a specific module (i.e. a merge of the pre-cached
   # `env_lookup_options` and the module specific data)
@@ -352,12 +357,12 @@ class LookupAdapter < DataAdapter
             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
-              elsif module_opts
-                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
+                       module_opts
+                     elsif module_opts
+                       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
           compile_patterns(opts)
@@ -368,7 +373,7 @@ class LookupAdapter < DataAdapter
 
   # Retrieve and cache the global lookup options
   def global_lookup_options(lookup_invocation, merge_strategy)
-    if !instance_variable_defined?(:@global_lookup_options)
+    unless instance_variable_defined?(:@global_lookup_options)
       @global_lookup_options = nil
       catch(:no_such_key) { @global_lookup_options = validate_lookup_options(lookup_global(LookupKey::LOOKUP_OPTIONS, lookup_invocation, merge_strategy), nil) }
     end
@@ -378,7 +383,7 @@ class LookupAdapter < DataAdapter
   # Retrieve and cache lookup options specific to the environment of the compiler that this adapter is attached to (i.e. a merge
   # of global and environment lookup options).
   def env_lookup_options(lookup_invocation, merge_strategy)
-    if !instance_variable_defined?(:@env_lookup_options)
+    unless instance_variable_defined?(:@env_lookup_options)
       global_options = global_lookup_options(lookup_invocation, merge_strategy)
       @env_only_lookup_options = nil
       catch(:no_such_key) { @env_only_lookup_options = validate_lookup_options(lookup_in_environment(LookupKey::LOOKUP_OPTIONS, lookup_invocation, merge_strategy), nil) }
@@ -406,7 +411,7 @@ class LookupAdapter < DataAdapter
   def module_provider(lookup_invocation, module_name)
     # Test if the key is present for the given module_name. It might be there even if the
     # value is nil (which indicates that no module provider is configured for the given name)
-    unless self.include?(module_name)
+    unless include?(module_name)
       self[module_name] = initialize_module_provider(lookup_invocation, module_name)
     end
     self[module_name]
@@ -429,7 +434,7 @@ class LookupAdapter < DataAdapter
       elsif mp_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
           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)
+                           _("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
@@ -478,11 +483,11 @@ class LookupAdapter < DataAdapter
       elsif ep_config.version >= 5
         unless provider_name.nil? || Puppet[:strict] == :off
           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')
+                           _("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('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')
+                             _("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
@@ -509,7 +514,7 @@ class LookupAdapter < DataAdapter
         ep.config = HieraConfigV5.v4_function_config(env_path, 'environment::data', ep)
         ep
       else
-        raise Puppet::Error.new(_("Environment '%{env}', cannot find environment_data_provider '%{provider}'") % { env: environment.name, provider: provider_name })
+        raise Puppet::Error, _("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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sub_lookup'
 
 module Puppet::Pops
@@ -14,7 +16,7 @@ class LookupKey
     qual_index = root_key.index(DOUBLE_COLON)
 
     @key = key
-    @module_name = qual_index.nil? ? nil : root_key[0..qual_index-1].freeze
+    @module_name = qual_index.nil? ? nil : root_key[0..qual_index - 1].freeze
     @root_key = root_key
     @segments = segments.empty? ? nil : segments.freeze
   end

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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require_relative 'function_provider'
 
 module Puppet::Pops
 module Lookup
 # @api private
 class LookupKeyFunctionProvider < FunctionProvider
-  TAG = 'lookup_key'.freeze
+  TAG = 'lookup_key'
 
   # Performs a lookup with the assumption that a recursive check has been made.
   #
@@ -64,7 +66,7 @@ end
 
 # @api private
 class V3LookupKeyFunctionProvider < LookupKeyFunctionProvider
-  TAG = 'v3_lookup_key'.freeze
+  TAG = 'v3_lookup_key'
 
   def initialize(name, parent_data_provider, function_name, options, locations)
     @datadir = options.delete(HieraConfig::KEY_DATADIR)

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

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require_relative 'configured_data_provider'
 
 module Puppet::Pops
 module Lookup
 # @api private
 class ModuleDataProvider < ConfiguredDataProvider
-
   attr_reader :module_name
 
   def initialize(module_name, config = nil)
@@ -46,15 +47,16 @@ class ModuleDataProvider < ConfiguredDataProvider
   def validate_data_hash(data_hash)
     super
     module_prefix = "#{module_name}::"
-    data_hash.each_key.reduce(data_hash) do |memo, k|
-      next memo if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
-      msg = "#{yield} must use keys qualified with the name of the module"
-      memo = memo.clone if memo.equal?(data_hash)
-      memo.delete(k)
-      Puppet.warning("Module '#{module_name}': #{msg}")
-      memo
+    data_hash_to_return = {}
+    data_hash.keys.each do |k|
+      if k == LOOKUP_OPTIONS || k.start_with?(module_prefix)
+        data_hash_to_return[k] = data_hash[k]
+      else
+        msg = "#{yield} must use keys qualified with the name of the module"
+        Puppet.warning("Module '#{module_name}': #{msg}; got #{k}")
+      end
     end
-    data_hash
+    data_hash_to_return
   end
 
   protected
@@ -82,6 +84,7 @@ class ModuleDataProvider < ConfiguredDataProvider
     env = lookup_invocation.scope.environment
     mod = env.module(module_name)
     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

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Lookup
 module SubLookup
-  SPECIAL = /['"\.]/
+  SPECIAL = /['".]/
 
   # Split key into segments. A segment may be a quoted string (both single and double quotes can
   # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on
@@ -18,6 +20,7 @@ module SubLookup
   # @api public
   def split_key(key)
     return [key] if key.match(SPECIAL).nil?
+
     segments = key.split(/(\s*"[^"]+"\s*|\s*'[^']+'\s*|[^'".]+)/)
     if segments.empty?
       # Only happens if the original key was an empty string
@@ -28,6 +31,7 @@ module SubLookup
 
       segments.keep_if { |seg| seg != '.' }
       raise yield('Syntax error') unless segments.size * 2 == count + 1
+
       segments.map! do |segment|
         segment.strip!
         if segment.start_with?('"', "'")
@@ -72,8 +76,8 @@ module SubLookup
           else
             unless value.respond_to?(:'[]') && !(value.is_a?(Array) || value.instance_of?(String))
               raise Puppet::DataBinding::LookupError,
-                _("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 }
+                    _("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

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
 module Puppet::Pops
 module Lookup
-  LOOKUP_OPTIONS = 'lookup_options'.freeze
-  GLOBAL = '__global__'.freeze
+  LOOKUP_OPTIONS = 'lookup_options'
+  GLOBAL = '__global__'
 
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
@@ -26,22 +28,26 @@ module Lookup
     # with name and value.
     not_found = MergeStrategy::NOT_FOUND
     override_values = lookup_invocation.override_values
-    result_with_name = names.reduce([nil, not_found]) do |memo, key|
+    result_with_name = [nil, not_found]
+    names.each do |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, false) } if value.equal?(not_found)
-      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
-      memo
+      next if value.equal?(not_found)
+
+      result_with_name = [key, assert_type('Found value', value_type, value)]
+      break
     end
 
     # Use the 'default_values' hash as a last resort if nothing is found
     if result_with_name[1].equal?(not_found)
       default_values = lookup_invocation.default_values
       unless default_values.empty?
-        result_with_name = names.reduce(result_with_name) do |memo, key|
+        names.each do |key|
           value = default_values.include?(key) ? assert_type(["Value found for key '%s' in default values hash", key], value_type, default_values[key]) : not_found
-          memo = [key, value]
-          break memo unless value.equal?(not_found)
-          memo
+          next if value.equal?(not_found)
+
+          result_with_name = [key, value]
+          break
         end
       end
     end
@@ -86,8 +92,7 @@ module Lookup
   def self.fail_lookup(names)
     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(', ') }
+             "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