puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

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

@@ -1,23 +1,28 @@
 require_relative 'sub_lookup'
-
-# Add support for Hiera-like interpolation expressions. The expressions may contain keys that uses dot-notation
-# to further navigate into hashes and arrays
-#
 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
 
-  def interpolate(subject, lookup_invocation, allow_methods)
-    case subject
+  # @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
-      subject.index('%{').nil? ? subject : interpolate_string(subject, lookup_invocation, allow_methods)
+      value.index('%{').nil? ? value : interpolate_string(value, context, allow_methods)
     when Array
-      subject.map { |element| interpolate(element, lookup_invocation, allow_methods) }
+      value.map { |element| interpolate(element, context, allow_methods) }
     when Hash
-      Hash[subject.map { |k, v| [k, interpolate(v, lookup_invocation, allow_methods)] }]
+      Hash[value.map { |k, v| [k, interpolate(v, context, allow_methods)] }]
     else
-      subject
+      value
     end
   end
 
@@ -35,7 +40,8 @@ module Interpolation
   # Matches a key that is quoted using a matching pair of either single or double quotes.
   QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
 
-  def interpolate_string(subject, lookup_invocation, allow_methods)
+  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
@@ -44,16 +50,12 @@ module Interpolation
         value = nil
         unless EMPTY_INTERPOLATIONS[expr]
           method_key, key = get_method_and_data(expr, allow_methods)
-          is_alias = method_key == 'alias'
+          is_alias = method_key == :alias
 
           # Alias is only permitted if the entire string is equal to the interpolate expression
           raise Puppet::DataBinding::LookupError, "'alias' interpolation is only permitted if the expression is equal to the entire string" if is_alias && subject != match
-
-          segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }
-          root_key = segments.shift
-          value = interpolate_method(method_key).call(root_key, lookup_invocation)
-          value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
-          value = lookup_invocation.check(key) { interpolate(value, lookup_invocation, allow_methods) }
+          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
@@ -65,34 +67,44 @@ module Interpolation
 
   def interpolate_method(method_key)
     @@interpolate_methods ||= begin
-      global_lookup = lambda { |key, lookup_invocation| Lookup.lookup(key, nil, '', true, nil, lookup_invocation) }
-      scope_lookup = lambda do |key, lookup_invocation|
-        lookup_invocation.with(:scope, nil) do
+      global_lookup = lambda { |key, lookup_invocation, _| Lookup.lookup(key, nil, '', true, nil, lookup_invocation) }
+      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?(key)
-            lookup_invocation.report_found_in_overrides(key, ovr[key])
+          if ovr.include?(root_key)
+            lookup_invocation.report_found_in_overrides(root_key, ovr[root_key])
           else
             scope = lookup_invocation.scope
-            if scope.include?(key)
-              lookup_invocation.report_found(key, scope[key])
-            else
+            val = scope[root_key]
+            if val.nil? && !nil_in_scope?(scope, root_key)
               defaults = lookup_invocation.default_values
-              if defaults.include?(key)
-                lookup_invocation.report_found_in_defaults(key, defaults[key])
+              if defaults.include?(root_key)
+                lookup_invocation.report_found_in_defaults(root_key, defaults[root_key])
               else
                 nil
               end
+            else
+              lookup_invocation.report_found(root_key, val)
             end
           end
         end
+        unless segments.empty?
+          found = '';
+          catch(:no_such_key) { found = sub_lookup(key, lookup_invocation, segments, value) }
+          value = found;
+        end
+        lookup_invocation.remember_scope_lookup(key, 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' => lambda { |key, _| key }
+        :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 => lambda { |key, _, _| key }
       }.freeze
     end
     interpolate_method = @@interpolate_methods[method_key]
@@ -100,13 +112,22 @@ module Interpolation
     interpolate_method
   end
 
+  # Because the semanitcs 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)
     if match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
       raise Puppet::DataBinding::LookupError, 'Interpolation using method syntax is not allowed in this context' unless allow_methods
-      key = match[1]
+      key = match[1].to_sym
       data = match[2] || match[3] # double or single qouted
     else
-      key = 'scope'
+      key = :scope
     end
     [key, data]
   end

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

@@ -1,134 +1,212 @@
-module Puppet::Pops::Lookup
-  class Invocation
-    attr_reader :scope, :override_values, :default_values, :explainer
-    attr_accessor :module_name, :top_key
+require_relative 'explainer'
 
-    def self.current
-        nil # TODO, determine how to obtain the current lookup invocation.
-    end
+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
+  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 = {}, default_values = {}, explainer = nil)
+  # 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 = LookupAdapter)
+    @scope = scope
+    @override_values = override_values
+    @default_values = default_values
+
+    parent_invocation = self.class.current
+    if parent_invocation.nil?
       @name_stack = []
-      @scope = scope
-      @override_values = override_values
-      @default_values = default_values
+      @adapter_class = 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)
-      @explainer = explainer
-    end
-
-    def check(name)
-      if @name_stack.include?(name)
-        raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@name_stack.join(', ')}]"
-      end
-      return unless block_given?
+    else
+      @name_stack = parent_invocation.name_stack
+      @adapter_class = parent_invocation.adapter_class
+      set_global_only if parent_invocation.global_only?
+      povr = parent_invocation.hiera_v3_location_overrides
+      set_hiera_v3_location_overrides(povr) unless povr.empty?
+      explainer = explainer == false ? nil : parent_invocation.explainer
+    end
+    @explainer = explainer
+  end
 
-      @name_stack.push(name)
+  def lookup(key, module_name)
+    @top_key = key
+    @module_name = module_name
+    save_current = self.class.current
+    if save_current.equal?(self)
+      yield
+    else
       begin
+        self.class.instance_variable_set(:@current, self)
         yield
-      rescue Puppet::DataBinding::LookupError
-        raise
-      rescue Puppet::Error => detail
-        raise Puppet::DataBinding::LookupError.new(detail.message, detail)
       ensure
-        @name_stack.pop
+        self.class.instance_variable_set(:@current, save_current)
       end
     end
+  end
 
-    def emit_debug_info(preamble)
-      @explainer.emit_debug_info(preamble) if @explainer.is_a?(DebugExplainer)
+  def check(name)
+    if @name_stack.include?(name)
+      raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@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, detail)
+    ensure
+      @name_stack.pop
+    end
+  end
+
+  def emit_debug_info(preamble)
+    @explainer.emit_debug_info(preamble) if @explainer.is_a?(DebugExplainer)
+  end
+
+  def lookup_adapter
+    @adapter ||= @adapter_class.adapt(scope.compiler)
+  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
-    # :module - qualifier is the name of a module
-    # :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?
+  # 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(key, value)
+    # 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
-      else
-        @explainer.push(qualifier_type, qualifier)
-        begin
-          yield
-        ensure
-          @explainer.pop
-        end
+      ensure
+        @explainer.pop
       end
     end
+  end
 
-    def only_explain_options?
-      @explainer.nil? ? false : @explainer.only_explain_options?
-    end
+  def only_explain_options?
+    @explainer.nil? ? false : @explainer.only_explain_options?
+  end
 
-    def explain_options?
-      @explainer.nil? ? false : @explainer.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_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_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_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
+  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
+  # 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_not_found(key)
+    @explainer.accept_not_found(key) unless @explainer.nil?
+  end
 
-    def report_path_not_found
-      @explainer.accept_path_not_found unless @explainer.nil?
-    end
+  def report_location_not_found
+    @explainer.accept_location_not_found unless @explainer.nil?
+  end
 
-    def report_module_not_found
-      @explainer.accept_module_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_text(&block)
-      unless @explainer.nil?
-        @explainer.accept_text(block.call)
-      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
-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
+
+  # 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/location_resolver.rb

@@ -0,0 +1,72 @@
+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
+  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 = interpolate(declared_glob, lookup_invocation, false)
+        Pathname.glob(datadir, glob).reject { |path| path.directory? }.map { |path| ResolvedLocation.new(glob, 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
+  end
+end
+end