puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

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

@@ -0,0 +1,102 @@
+module Puppet::Pops
+module Lookup
+# @api private
+module DataProvider
+  def self.key_type
+    ensure_types_initialized
+    @key_type
+  end
+
+  def self.value_type
+    ensure_types_initialized
+    @value_type
+  end
+
+  def self.ensure_types_initialized
+    if @key_type.nil?
+      (@key_type, @value_type) = Pcore::register_aliases(
+        # The Pcore type for all keys and subkeys in a data hash.
+        'Puppet::LookupKey' => 'Variant[String,Numeric]',
+
+        # The Pcore type for all values and sub-values in a data hash. The
+        # type is self-recursive to enforce the same constraint on values contained
+        # in arrays and hashes
+        'Puppet::LookupValue' => <<-PUPPET
+          Variant[
+            Scalar,
+            Undef,
+            Sensitive,
+            Type,
+            Hash[Puppet::LookupKey, Puppet::LookupValue],
+            Array[Puppet::LookupValue]
+          ]
+        PUPPET
+      )
+    end
+  end
+
+  # Performs a lookup with an endless recursion check.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
+  #
+  def key_lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  def lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'unchecked_lookup' method"
+  end
+
+  # @return [String,nil] the name of the module that this provider belongs to nor `nil` if it doesn't belong to a module
+  def module_name
+    nil
+  end
+
+  # @return [String] the name of the this data provider
+  def name
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'name' method"
+  end
+
+  # Asserts that _data_hash_ is a valid hash.
+  #
+  # @param data_provider [DataProvider] The data provider that produced the hash
+  # @param data_hash [Hash{String=>Object}] The data hash
+  # @return [Hash{String=>Object}] The data hash
+  def validate_data_hash(data_provider, data_hash)
+    Types::TypeAsserter.assert_instance_of(nil, Types::PHashType::DEFAULT, data_hash) { "Value returned from #{data_provider.name}" }
+    data_hash.each_pair { |k, v| validate_data_entry(data_provider, k, v) }
+    data_hash
+  end
+
+  def validate_data_value(data_provider, value, where = '')
+    Types::TypeAsserter.assert_instance_of(nil, DataProvider.value_type, value) { "Value #{where}returned from #{data_provider.name}" }
+    case value
+    when Hash
+      value.each_pair { |k, v| validate_data_entry(data_provider, k, v) }
+    when Array
+      value.each {|v| validate_data_value(data_provider, v, 'in array ') }
+    end
+    value
+  end
+
+  def validate_data_entry(data_provider, key, value)
+    Types::TypeAsserter.assert_instance_of(nil, DataProvider.key_type, key) { "Key in hash returned from #{data_provider.name}" }
+    validate_data_value(data_provider, value, 'in hash ')
+    nil
+  end
+end
+end
+end

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