openvox 8.19.0

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'hiera/scope'
+require_relative 'sub_lookup'
+module Puppet::Pops
+module Lookup
+# Adds support for interpolation expressions. The expressions may contain keys that uses dot-notation
+# to further navigate into hashes and arrays
+#
+# @api public
+module Interpolation
+  include SubLookup
+
+  # @param value [Object] The value to interpolate
+  # @param context [Context] The current lookup context
+  # @param allow_methods [Boolean] `true` if interpolation expression that contains lookup methods are allowed
+  # @return [Object] the result of resolving all interpolations in the given value
+  # @api public
+  def interpolate(value, context, allow_methods)
+    case value
+    when String
+      value.index('%{').nil? ? value : interpolate_string(value, context, allow_methods)
+    when Array
+      value.map { |element| interpolate(element, context, allow_methods) }
+    when Hash
+      result = {}
+      value.each_pair { |k, v| result[interpolate(k, context, allow_methods)] = interpolate(v, context, allow_methods) }
+      result
+    else
+      value
+    end
+  end
+
+  private
+
+  EMPTY_INTERPOLATIONS = {
+    '' => true,
+    '::' => true,
+    '""' => true,
+    "''" => true,
+    '"::"' => true,
+    "'::'" => true
+  }.freeze
+
+  # Matches a key that is quoted using a matching pair of either single or double quotes.
+  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
+
+  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 = ::Regexp.last_match(1)
+        # Leading and trailing spaces inside an interpolation expression are insignificant
+        expr.strip!
+        value = nil
+        unless EMPTY_INTERPOLATIONS[expr]
+          method_key, key = get_method_and_data(expr, allow_methods)
+          is_alias = method_key == :alias
+
+          # 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
+          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
+    end
+  end
+
+  def interpolate_method(method_key)
+    @@interpolate_methods ||= begin
+      global_lookup = lambda do |key, lookup_invocation, _|
+        scope = lookup_invocation.scope
+        if scope.is_a?(Hiera::Scope) && !lookup_invocation.global_only?
+          # "unwrap" the Hiera::Scope
+          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
+      end
+      scope_lookup = lambda do |key, lookup_invocation, subject|
+        segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }
+        root_key = segments.shift
+        value = lookup_invocation.with(:scope, 'Global Scope') do
+          ovr = lookup_invocation.override_values
+          if ovr.include?(root_key)
+            lookup_invocation.report_found_in_overrides(root_key, ovr[root_key])
+          else
+            scope = lookup_invocation.scope
+            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)
+              if default_key_exists
+                lookup_invocation.report_found_in_defaults(root_key,
+                                                           lookup_invocation.default_values[root_key])
+              else
+                nil
+              end
+            else
+              lookup_invocation.report_found(root_key, val)
+            end
+          end
+        end
+        unless value.nil? || segments.empty?
+          found = nil;
+          catch(:no_such_key) { found = sub_lookup(key, lookup_invocation, segments, value) }
+          value = found;
+        end
+        lookup_invocation.remember_scope_lookup(key, root_key, segments, value)
+        value
+      end
+
+      {
+        :lookup => global_lookup,
+        :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 => ->(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
+
+  # Because the semantics of Puppet::Parser::Scope#include? differs from Hash#include?
+  def nil_in_scope?(scope, key)
+    if scope.is_a?(Hash)
+      scope.include?(key)
+    else
+      scope.exist?(key)
+    end
+  end
+
+  def get_method_and_data(data, allow_methods)
+    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
+      key = :scope
+    end
+    [key, data]
+  end
+
+  def fail(issue, args = EMPTY_HASH)
+    raise Puppet::DataBinding::LookupError.new(
+      issue.format(args), nil, nil, nil, nil, issue.issue_code
+    )
+  end
+end
+end
+end

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

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require_relative '../../../puppet/thread_local'
+
+require_relative 'explainer'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class Invocation
+  attr_reader :scope, :override_values, :default_values, :explainer, :module_name, :top_key, :adapter_class
+
+  def self.current
+    (@current ||= Puppet::ThreadLocal.new(nil)).value
+  end
+
+  def self.current=(new_value)
+    @current.value = new_value
+  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.
+  #
+  # If the _explain_ argument is a boolean, then _false_ means that no explanation is needed and _true_ means that
+  # the default explanation acceptor should be used. The _explain_ argument may also be an instance of the
+  # `ExplanationAcceptor` class.
+  #
+  # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
+  # @param override_values [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
+  # @param default_values [Hash<String,Object>] A map to use as the last resort (but before default)
+  # @param explainer [boolean,Explanainer] An boolean true to use the default explanation acceptor or an explainer instance that will receive information about the lookup
+  def initialize(scope, override_values = EMPTY_HASH, default_values = EMPTY_HASH, explainer = nil, adapter_class = nil)
+    @scope = scope
+    @override_values = override_values
+    @default_values = default_values
+
+    parent_invocation = self.class.current
+
+    if parent_invocation && (adapter_class.nil? || adapter_class == parent_invocation.adapter_class)
+      # Inherit from parent invocation (track recursion)
+      @name_stack = parent_invocation.name_stack
+      @adapter_class = parent_invocation.adapter_class
+
+      # Inherit Hiera 3 legacy properties
+      set_hiera_xxx_call if parent_invocation.hiera_xxx_call?
+      set_hiera_v3_merge_behavior if parent_invocation.hiera_v3_merge_behavior?
+      set_global_only if parent_invocation.global_only?
+      povr = parent_invocation.hiera_v3_location_overrides
+      set_hiera_v3_location_overrides(povr) unless povr.empty?
+
+      # Inherit explainer unless a new explainer is given or disabled using false
+      explainer = explainer == false ? nil : parent_invocation.explainer
+    else
+      @name_stack = []
+      @adapter_class = adapter_class.nil? ? LookupAdapter : adapter_class
+      unless explainer.is_a?(Explainer)
+        explainer = explainer == true ? Explainer.new : nil
+      end
+      explainer = DebugExplainer.new(explainer) if Puppet[:debug] && !explainer.is_a?(DebugExplainer)
+    end
+    @explainer = explainer
+  end
+
+  def lookup(key, module_name = nil)
+    key = LookupKey.new(key) unless key.is_a?(LookupKey)
+    @top_key = key
+    @module_name = module_name.nil? ? key.module_name : module_name
+    save_current = self.class.current
+    if save_current.equal?(self)
+      yield
+    else
+      begin
+        self.class.current = self
+        yield
+      ensure
+        self.class.current = save_current
+      end
+    end
+  end
+
+  def check(name)
+    if @name_stack.include?(name)
+      raise Puppet::DataBinding::RecursiveLookupError, _("Recursive lookup detected in [%{name_stack}]") % { name_stack: @name_stack.join(', ') }
+    end
+    return unless block_given?
+
+    @name_stack.push(name)
+    begin
+      yield
+    rescue Puppet::DataBinding::LookupError
+      raise
+    rescue Puppet::Error => detail
+      raise Puppet::DataBinding::LookupError.new(detail.message, nil, nil, nil, detail)
+    ensure
+      @name_stack.pop
+    end
+  end
+
+  def emit_debug_info(preamble)
+    @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
+  # values that the configuration was based on
+  #
+  # @api private
+  def remember_scope_lookup(*lookup_result)
+    # Does nothing by default
+  end
+
+  # The qualifier_type can be one of:
+  # :global - qualifier is the data binding terminus name
+  # :data_provider - qualifier a DataProvider instance
+  # :path - qualifier is a ResolvedPath instance
+  # :merge - qualifier is a MergeStrategy instance
+  # :interpolation - qualifier is the unresolved interpolation expression
+  # :meta - qualifier is the module name
+  # :data - qualifier is the key
+  #
+  # @param qualifier [Object] A branch, a provider, or a path
+  def with(qualifier_type, qualifier)
+    if explainer.nil?
+      yield
+    else
+      @explainer.push(qualifier_type, qualifier)
+      begin
+        yield
+      ensure
+        @explainer.pop
+      end
+    end
+  end
+
+  def without_explain
+    if explainer.nil?
+      yield
+    else
+      save_explainer = @explainer
+      begin
+        @explainer = nil
+        yield
+      ensure
+        @explainer = save_explainer
+      end
+    end
+  end
+
+  def only_explain_options?
+    @explainer.nil? ? false : @explainer.only_explain_options?
+  end
+
+  def explain_options?
+    @explainer.nil? ? false : @explainer.explain_options?
+  end
+
+  def report_found_in_overrides(key, value)
+    @explainer.accept_found_in_overrides(key, value) unless @explainer.nil?
+    value
+  end
+
+  def report_found_in_defaults(key, value)
+    @explainer.accept_found_in_defaults(key, value) unless @explainer.nil?
+    value
+  end
+
+  def report_found(key, value)
+    @explainer.accept_found(key, value) unless @explainer.nil?
+    value
+  end
+
+  def report_merge_source(merge_source)
+    @explainer.accept_merge_source(merge_source) unless @explainer.nil?
+  end
+
+  # Report the result of a merge or fully resolved interpolated string
+  # @param value [Object] The result to report
+  # @return [Object] the given value
+  def report_result(value)
+    @explainer.accept_result(value) unless @explainer.nil?
+    value
+  end
+
+  def report_not_found(key)
+    @explainer.accept_not_found(key) unless @explainer.nil?
+  end
+
+  def report_location_not_found
+    @explainer.accept_location_not_found unless @explainer.nil?
+  end
+
+  def report_module_not_found(module_name)
+    @explainer.accept_module_not_found(module_name) unless @explainer.nil?
+  end
+
+  def report_module_provider_not_found(module_name)
+    @explainer.accept_module_provider_not_found(module_name) unless @explainer.nil?
+  end
+
+  def report_text(&block)
+    unless @explainer.nil?
+      @explainer.accept_text(block.call)
+    end
+  end
+
+  def global_only?
+    lookup_adapter.global_only? || (instance_variable_defined?(:@global_only) ? @global_only : false)
+  end
+
+  # Instructs the lookup framework to only perform lookups in the global layer
+  # @return [Invocation] self
+  def set_global_only
+    @global_only = true
+    self
+  end
+
+  # @return [Pathname] the full path of the hiera.yaml config file
+  def global_hiera_config_path
+    lookup_adapter.global_hiera_config_path
+  end
+
+  # @return [Boolean] `true` if the invocation stems from the hiera_xxx function family
+  def hiera_xxx_call?
+    instance_variable_defined?(:@hiera_xxx_call)
+  end
+
+  def set_hiera_xxx_call
+    @hiera_xxx_call = true
+  end
+
+  # @return [Boolean] `true` if the invocation stems from the hiera_xxx function family
+  def hiera_v3_merge_behavior?
+    instance_variable_defined?(:@hiera_v3_merge_behavior)
+  end
+
+  def set_hiera_v3_merge_behavior
+    @hiera_v3_merge_behavior = true
+  end
+
+  # Overrides passed from hiera_xxx functions down to V3DataHashFunctionProvider
+  def set_hiera_v3_location_overrides(overrides)
+    @hiera_v3_location_overrides = [overrides].flatten unless overrides.nil?
+  end
+
+  def hiera_v3_location_overrides
+    instance_variable_defined?(:@hiera_v3_location_overrides) ? @hiera_v3_location_overrides : EMPTY_ARRAY
+  end
+
+  protected
+
+  def name_stack
+    @name_stack.clone
+  end
+end
+end
+end

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

@@ -0,0 +1,21 @@
+# 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
+  end
+
+  # rubocop:disable Naming/MemoizedInstanceVariableName
+  def self.singleton
+    @null_recorder ||= new
+  end
+  # rubocop:enable Naming/MemoizedInstanceVariableName
+
+  # Records a key
+  # (This implementation does nothing)
+  #
+  def record(key)
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative 'interpolation'
+
+module Puppet::Pops
+module Lookup
+  # Class that keeps track of the original location (as it appears in the declaration, before interpolation),
+  # and the fully resolved location, and whether or not the resolved location exists.
+  #
+  # @api private
+  class ResolvedLocation
+    attr_reader :original_location, :location
+
+    # @param original_location [String] location as found in declaration. May contain interpolation expressions
+    # @param location [Pathname,URI] the expanded location
+    # @param exist [Boolean] `true` if the location is assumed to exist
+    # @api public
+    def initialize(original_location, location, exist)
+      @original_location = original_location
+      @location = location
+      @exist = exist
+    end
+
+    # @return [Boolean] `true` if the location is assumed to exist
+    # @api public
+    def exist?
+      @exist
+    end
+
+    # @return the resolved location as a string
+    def to_s
+      @location.to_s
+    end
+  end
+
+  # Helper methods to resolve interpolated locations
+  #
+  # @api private
+  module LocationResolver
+    include Interpolation
+
+    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(&:directory?).map { |path| ResolvedLocation.new(glob.to_s, path, true) }
+      end.flatten
+    end
+
+    # @param datadir [Pathname] The base when creating absolute paths
+    # @param declared_paths [Array<String>] paths as found in declaration. May contain interpolation expressions
+    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
+    # @param is_default_config [Boolean] `true` if this is the default config and non-existent paths should be excluded
+    # @param extension [String] Required extension such as '.yaml' or '.json'. Use only if paths without extension can be expected
+    # @return [Array<ResolvedLocation>] Array of resolved paths
+    def resolve_paths(datadir, declared_paths, lookup_invocation, is_default_config, extension = nil)
+      result = []
+      declared_paths.each do |declared_path|
+        path = interpolate(declared_path, lookup_invocation, false)
+        path += extension unless extension.nil? || path.end_with?(extension)
+        path = datadir + path
+        path_exists = path.exist?
+        result << ResolvedLocation.new(declared_path, path, path_exists) unless is_default_config && !path_exists
+      end
+      result
+    end
+
+    # @param declared_uris [Array<String>] paths as found in declaration. May contain interpolation expressions
+    # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] The current lookup invocation
+    # @return [Array<ResolvedLocation>] Array of resolved paths
+    def expand_uris(declared_uris, lookup_invocation)
+      declared_uris.map do |declared_uri|
+        uri = URI(interpolate(declared_uri, lookup_invocation, false))
+        ResolvedLocation.new(declared_uri, uri, true)
+      end
+    end
+
+    def expand_mapped_paths(datadir, mapped_path_triplet, lookup_invocation)
+      # The scope interpolation method is used directly to avoid unnecessary parsing of the string that otherwise
+      # would need to be generated
+      mapped_vars = interpolate_method(:scope).call(mapped_path_triplet[0], lookup_invocation, 'mapped_path[0]')
+
+      # No paths here unless the scope lookup returned something
+      return EMPTY_ARRAY if mapped_vars.nil? || mapped_vars.empty?
+
+      mapped_vars = [mapped_vars] if mapped_vars.is_a?(String)
+      var_key = mapped_path_triplet[1]
+      template = mapped_path_triplet[2]
+      scope = lookup_invocation.scope
+      lookup_invocation.with_local_memory_eluding(var_key) do
+        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) }
+          ResolvedLocation.new(template, path, path.exist?)
+        end
+      end
+    end
+  end
+end
+end