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

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

@@ -0,0 +1,27 @@
+require_relative 'configured_data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class EnvironmentDataProvider < ConfiguredDataProvider
+  def place
+    'Environment'
+  end
+
+  protected
+
+  def assert_config_version(config)
+    raise Puppet::DataBinding::LookupError, "#{config.name} cannot be used in an environment" unless config.version > 3
+    config
+  end
+
+  # Return the root of the environment
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to root of the environment
+  def provider_root(lookup_invocation)
+    Pathname.new(lookup_invocation.scope.environment.configuration.path_to_env)
+  end
+end
+end
+end

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

@@ -1,4 +1,5 @@
-module Puppet::Pops::Lookup
+module Puppet::Pops
+module Lookup
 
 # The ExplainNode contains information of a specific node in a tree traversed during
 # lookup. The tree can be traversed using the `parent` and `branches` attributes of
@@ -17,13 +18,33 @@ module Puppet::Pops::Lookup
       hash
     end
 
-    def to_s
+    def explain
       io = ''
       dump_on(io, '', '')
       io
     end
 
+    def inspect
+      to_s
+    end
+
+    def to_s
+      s = self.class.name
+      s = "#{s} with #{@branches.size} branches" unless @branches.nil?
+      s
+    end
+
+    def text(text)
+      @texts ||= []
+      @texts << text
+    end
+
     def dump_on(io, indent, first_indent)
+      dump_texts(io, indent)
+    end
+
+    def dump_texts(io, indent)
+      @texts.each { |text| io << indent << text << "\n" } if instance_variable_defined?(:@texts)
     end
   end
 
@@ -34,23 +55,22 @@ module Puppet::Pops::Lookup
     def initialize(parent)
       @parent = parent
       @event = nil
-      @texts = nil
     end
 
     def found_in_overrides(key, value)
-      @key = key
+      @key = key.to_s
       @value = value
       @event = :found_in_overrides
     end
 
     def found_in_defaults(key, value)
-      @key = key
+      @key = key.to_s
       @value = value
       @event = :found_in_defaults
     end
 
     def found(key, value)
-      @key = key
+      @key = key.to_s
       @value = value
       @event = :found
     end
@@ -60,22 +80,13 @@ module Puppet::Pops::Lookup
       @event = :result
     end
 
-    def text(text)
-      @texts ||= []
-      @texts << text
-    end
-
     def not_found(key)
-      @key = key
+      @key = key.to_s
       @event = :not_found
     end
 
-    def path_not_found
-      @event = :path_not_found
-    end
-
-    def module_not_found
-      @event = :module_not_found
+    def location_not_found
+      @event = :location_not_found
     end
 
     def increase_indent(indent)
@@ -97,19 +108,17 @@ module Puppet::Pops::Lookup
     end
 
     def dump_outcome(io, indent)
-      io << indent << 'No such key: "' << @key << "\"\n" if @event == :not_found
-      if [:found, :found_in_overrides, :found_in_defaults].include?(@event)
+      case @event
+      when :not_found
+        io << indent << 'No such key: "' << @key << "\"\n"
+      when :found, :found_in_overrides, :found_in_defaults
         io << indent << 'Found key: "' << @key << '" value: '
         dump_value(io, indent, @value)
         io << ' in overrides' if @event == :found_in_overrides
         io << ' in defaults' if @event == :found_in_defaults
         io << "\n"
       end
-      dump_texts(io, indent, @texts)
-    end
-
-    def dump_texts(io, indent, texts)
-      texts.each { |text| io << indent << text << "\n" } unless texts.nil?
+      dump_texts(io, indent)
     end
 
     def dump_value(io, indent, value)
@@ -144,13 +153,17 @@ module Puppet::Pops::Lookup
         io << value.inspect
       end
     end
+
+    def to_s
+      "#{self.class.name}: #{@key}, #{@event}"
+    end
   end
 
   class ExplainTop < ExplainTreeNode
     def initialize(parent, type, key)
       super(parent)
       @type = type
-      self.key = key
+      self.key = key.to_s
     end
 
     def dump_on(io, indent, first_indent)
@@ -163,7 +176,7 @@ module Puppet::Pops::Lookup
   class ExplainInvalidKey < ExplainTreeNode
     def initialize(parent, key)
       super(parent)
-      @key = key
+      @key = key.to_s
     end
 
     def dump_on(io, indent, first_indent)
@@ -195,6 +208,34 @@ module Puppet::Pops::Lookup
     end
   end
 
+  class ExplainModule < ExplainTreeNode
+    def initialize(parent, module_name)
+      super(parent)
+      @module_name = module_name
+    end
+
+    def dump_on(io, indent, first_indent)
+      case @event
+      when :module_not_found
+        io << indent << 'Module "' << @module_name << "\" not found\n"
+      when :module_provider_not_found
+        io << indent << 'Module data provider for module "' << @module_name << "\" not found\n"
+      end
+    end
+
+    def module_not_found
+      @event = :module_not_found
+    end
+
+    def module_provider_not_found
+      @event = :module_provider_not_found
+    end
+
+    def type
+      :module
+    end
+  end
+
   class ExplainInterpolate < ExplainTreeNode
     def initialize(parent, expression)
       super(parent)
@@ -269,39 +310,6 @@ module Puppet::Pops::Lookup
     end
   end
 
-  class ExplainModule < ExplainTreeNode
-    def initialize(parent, mod)
-      super(parent)
-      @module = mod
-    end
-
-    def dump_on(io, indent, first_indent)
-      io << indent << 'Module "' << @module << '"'
-      if branches.size == 1
-        branches[0].dump_on(io, indent, ' using ')
-      else
-        io << "\n"
-        indent = increase_indent(indent)
-        branches.each {|b| b.dump_on(io, indent, indent)}
-      end
-      io << indent << "Module not found\n" if @event == :module_not_found
-    end
-
-    def to_hash
-      if branches.size == 1
-        branches[0].to_hash.merge(:module => @module)
-      else
-        hash = super
-        hash[:module] = @module
-        hash
-      end
-    end
-
-    def type
-      :module
-    end
-  end
-
   class ExplainGlobal < ExplainTreeNode
     def initialize(parent, binding_terminus)
       super(parent)
@@ -333,9 +341,12 @@ module Puppet::Pops::Lookup
     end
 
     def dump_on(io, indent, first_indent)
-      io << first_indent << 'Data Provider "' << @provider.name << "\"\n"
+      io << first_indent << @provider.name << "\n"
       indent = increase_indent(indent)
-      io << indent << 'ConfigurationPath "' << @provider.config_path.to_s << "\"\n" if @provider.respond_to?(:config_path)
+      if @provider.respond_to?(:config_path)
+        path = @provider.config_path
+        io << indent << 'Using configuration "' << path.to_s << "\"\n" unless path.nil?
+      end
       branches.each {|b| b.dump_on(io, indent, indent)}
       dump_outcome(io, indent)
     end
@@ -343,7 +354,11 @@ module Puppet::Pops::Lookup
     def to_hash
       hash = super
       hash[:name] = @provider.name
-      hash[:configuration_path] = @provider.config_path.to_s if @provider.respond_to?(:config_path)
+      if @provider.respond_to?(:config_path)
+        path = @provider.config_path
+        hash[:configuration_path] = path.to_s unless path.nil?
+      end
+      hash[:module] = @provider.module_name if @provider.is_a?(ModuleDataProvider)
       hash
     end
 
@@ -352,30 +367,38 @@ module Puppet::Pops::Lookup
     end
   end
 
-  class ExplainPath < ExplainTreeNode
-    def initialize(parent, path)
+  class ExplainLocation < ExplainTreeNode
+    def initialize(parent, location)
       super(parent)
-      @path = path
+      @location = location
     end
 
     def dump_on(io, indent, first_indent)
-      io << indent << 'Path "' << @path.path.to_s << "\"\n"
+      location = @location.location
+      type_name = type == :path ? 'Path' : 'URI'
+      io << indent << type_name << ' "' << location.to_s << "\"\n"
       indent = increase_indent(indent)
-      io << indent << 'Original path: "' << @path.original_path << "\"\n"
+      io << indent << 'Original ' << type_name.downcase << ': "' << @location.original_location << "\"\n"
       branches.each {|b| b.dump_on(io, indent, indent)}
-      io << indent << "Path not found\n" if @event == :path_not_found
+      io << indent << type_name << " not found\n" if @event == :location_not_found
       dump_outcome(io, indent)
     end
 
     def to_hash
       hash = super
-      hash[:original_path] = @path.original_path
-      hash[:path] = @path.path.to_s
+      location = @location.location
+      if type == :path
+        hash[:original_path] = @location.original_location
+        hash[:path] = location.to_s
+      else
+        hash[:original_uri] = @location.original_location
+        hash[:uri] = location.to_s
+      end
       hash
     end
 
     def type
-      :path
+      @location.location.is_a?(Pathname) ? :path : :uri
     end
   end
 
@@ -413,16 +436,23 @@ module Puppet::Pops::Lookup
   end
 
   class ExplainScope < ExplainTreeNode
-    def initialize(parent)
+    def initialize(parent, name)
       super(parent)
+      @name = name
     end
 
     def dump_on(io, indent, first_indent)
-      io << indent << 'Global Scope' << "\n"
+      io << indent << @name << "\n"
       indent = increase_indent(indent)
       dump_outcome(io, indent)
     end
 
+    def to_hash
+      hash = super
+      hash[:name] = @name
+      hash
+    end
+
     def type
       :scope
     end
@@ -439,18 +469,18 @@ module Puppet::Pops::Lookup
       node = case (qualifier_type)
         when :global
          ExplainGlobal.new(@current, qualifier)
-        when :path
-          ExplainPath.new(@current, qualifier)
-        when :module
-          ExplainModule.new(@current, qualifier)
+        when :location
+          ExplainLocation.new(@current, qualifier)
         when :interpolate
           ExplainInterpolate.new(@current, qualifier)
         when :data_provider
           ExplainDataProvider.new(@current, qualifier)
         when :merge
           ExplainMerge.new(@current, qualifier)
+        when :module
+          ExplainModule.new(@current, qualifier)
         when :scope
-          ExplainScope.new(@current)
+          ExplainScope.new(@current, qualifier)
         when :sub_lookup
           ExplainSubLookup.new(@current, qualifier)
         when :segment
@@ -498,12 +528,20 @@ module Puppet::Pops::Lookup
       @current.not_found(key)
     end
 
-    def accept_path_not_found
-      @current.path_not_found
+    def accept_location_not_found
+      @current.location_not_found
     end
 
-    def accept_module_not_found
+    def accept_module_not_found(module_name)
+      push(:module, module_name)
       @current.module_not_found
+      pop
+    end
+
+    def accept_module_provider_not_found(module_name)
+      push(:module, module_name)
+      @current.module_provider_not_found
+      pop
     end
 
     def accept_result(result)
@@ -516,6 +554,7 @@ module Puppet::Pops::Lookup
 
     def dump_on(io, indent, first_indent)
       branches.each { |b| b.dump_on(io, indent, first_indent) }
+      dump_texts(io, indent)
     end
 
     def to_hash
@@ -551,3 +590,4 @@ module Puppet::Pops::Lookup
     end
   end
 end
+end

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

@@ -0,0 +1,82 @@
+require_relative 'data_adapter'
+require_relative 'context'
+require_relative 'data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class FunctionProvider
+  include DataProvider
+
+  attr_reader :parent_data_provider, :function_name, :locations
+
+  def initialize(name, parent_data_provider, function_name, options, locations)
+    @name = name
+    @parent_data_provider = parent_data_provider
+    @function_name = function_name
+    @options = options
+    @locations = locations || [nil]
+    @contexts = {}
+  end
+
+  # @return [FunctionContext] the function context associated with this provider
+  def function_context(lookup_invocation, location)
+    scope = lookup_invocation.scope
+    compiler = scope.compiler
+    @contexts[location] ||= FunctionContext.new(compiler.environment.name, module_name, function(scope))
+  end
+
+  def module_name
+    @parent_data_provider.module_name
+  end
+
+  def name
+    "Hierarchy entry \"#{@name}\""
+  end
+
+  def to_s
+    name
+  end
+
+  # Obtains the options to send to the function, optionally merged with a 'path' or 'uri' option
+  #
+  # @param [Pathname,URI] location The location to add to the options
+  # @return [Hash{String => Object}] The options hash
+  def options(location = nil)
+    case location
+    when nil
+      @options
+    when Pathname
+      @options.merge(HieraConfig::KEY_PATH => location.to_s)
+    when URI
+      @options.merge(HieraConfig::KEY_URI => location.to_s)
+    else
+      @options
+    end
+  end
+
+  private
+
+  def function(scope)
+    @function ||= load_function(scope)
+  end
+
+  def load_function(scope)
+    loaders = scope.compiler.loaders
+    typed_name = Loader::TypedName.new(:function, @function_name)
+    loader = if typed_name.qualified?
+      qualifier = typed_name.name_parts[0]
+      qualifier == 'environment' ? loaders.private_environment_loader : loaders.private_loader_for_module(qualifier)
+    else
+      loaders.private_environment_loader
+    end
+    te = loader.load_typed(typed_name)
+    if te.nil? || te.value.nil?
+      raise Puppet::DataBinding::LookupError,
+        "#{@options[HieraConfig::KEY_NAME]}: Unable to find '#{self.class::TAG}' function named '#{function_name}'"
+    end
+    te.value
+  end
+end
+end
+end

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

@@ -0,0 +1,49 @@
+require 'hiera/scope'
+require_relative 'configured_data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class GlobalDataProvider < ConfiguredDataProvider
+  def place
+    'Global'
+  end
+
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    config = config(lookup_invocation)
+    if(config.version == 3)
+      # Hiera version 3 needs access to special scope variables
+      scope = lookup_invocation.scope
+      unless scope.is_a?(Hiera::Scope)
+        lookup_invocation = Invocation.new(
+          Hiera::Scope.new(scope),
+          lookup_invocation.override_values,
+          lookup_invocation.default_values,
+          lookup_invocation.explainer)
+      end
+      merge = config.merge_strategy if merge.is_a?(DefaultMergeStrategy)
+    end
+    super(key, lookup_invocation, merge)
+  end
+
+  protected
+
+  def assert_config_version(config)
+    raise Puppet::DataBinding::LookupError, "#{config.name} cannot be used in the global layer" if config.version == 4
+    config
+  end
+
+  # Return the root of the environment
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to the parent of the hiera configuration file
+  def provider_root(lookup_invocation)
+    configuration_path(lookup_invocation).parent
+  end
+
+  def configuration_path(lookup_invocation)
+    lookup_invocation.global_hiera_config_path
+  end
+end
+end
+end