puppet 4.3.0 → 4.4.0

data/lib/puppet/pops/loader/puppet_function_instantiator.rb

@@ -1,19 +1,21 @@
+module Puppet::Pops
+module Loader
 # The PuppetFunctionInstantiator instantiates a Puppet::Functions::PuppetFunction given a Puppet Programming language
 # source that when called evaluates the Puppet logic it contains.
 #
-class Puppet::Pops::Loader::PuppetFunctionInstantiator
+class PuppetFunctionInstantiator
   # Produces an instance of the Function class with the given typed_name, or fails with an error if the
   # given puppet source does not produce this instance when evaluated.
   #
-  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
-  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
+  # @param loader [Loader] The loader the function is associated with
+  # @param typed_name [TypedName] the type / name of the function to load
   # @param source_ref [URI, String] a reference to the source / origin of the puppet code to evaluate
   # @param pp_code_string [String] puppet code in a string
   #
-  # @return [Puppet::Pops::Functions::Function] - an instantiated function with global scope closure associated with the given loader
+  # @return [Functions::Function] - an instantiated function with global scope closure associated with the given loader
   #
   def self.create(loader, typed_name, source_ref, pp_code_string)
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    parser = Parser::EvaluatingParser.new()
 
     # parse and validate
     result = parser.parse_string(pp_code_string, source_ref)
@@ -28,7 +30,7 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     end
     the_function_definition = result.model.definitions[0]
 
-    unless the_function_definition.is_a?(Puppet::Pops::Model::FunctionDefinition)
+    unless the_function_definition.is_a?(Model::FunctionDefinition)
       raise ArgumentError, "The code loaded from #{source_ref} does not define the function '#{typed_name.name}' - no function found."
     end
     unless the_function_definition.name == typed_name.name
@@ -43,7 +45,8 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     # Adapt the function definition with loader - this is used from logic contained in it body to find the
     # loader to use when making calls to the new function API. Such logic have a hard time finding the closure (where
     # the loader is known - hence this mechanism
-    Puppet::Pops::Adapters::LoaderAdapter.adapt(the_function_definition).loader = loader
+    private_loader = loader.private_loader
+    Adapters::LoaderAdapter.adapt(the_function_definition).loader = private_loader
 
     # TODO: Cheating wrt. scope - assuming it is found in the context
     closure_scope = Puppet.lookup(:global_scope) { {} }
@@ -53,26 +56,28 @@ class Puppet::Pops::Loader::PuppetFunctionInstantiator
     # when calling functions etc.
     # It should be bound to global scope
 
-    created.new(closure_scope, loader)
+    created.new(closure_scope, private_loader)
   end
 
   # Creates Function class and instantiates it based on a FunctionDefinition model
-  # @return [Array<Puppet::Pops::Loader::Loader::TypedName, Puppet::Pops::Functions.Function>] - array of 
+  # @return [Array<Loader::TypedName, Functions.Function>] - array of 
   #   typed name, and an instantiated function with global scope closure associated with the given loader
   #
   def self.create_from_model(function_definition, loader)
     closure_scope = Puppet.lookup(:global_scope) { {} }
     created = create_function_class(function_definition, closure_scope)
-    typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, function_definition.name)
+    typed_name = Loader::TypedName.new(:function, function_definition.name)
     [typed_name, created.new(closure_scope, loader)]
   end
 
   def self.create_function_class(function_definition, closure_scope)
     # Create a 4x function wrapper around a named closure
     Puppet::Functions.create_function(function_definition.name, Puppet::Functions::PuppetFunction) do
-      init_dispatch(Puppet::Pops::Evaluator::Closure::Named.new(
+      init_dispatch(Evaluator::Closure::Named.new(
         function_definition.name,
-        Puppet::Pops::Evaluator::EvaluatorImpl.new(), function_definition, closure_scope))
+        Evaluator::EvaluatorImpl.new(), function_definition, closure_scope))
     end
   end
-end
+end
+end
+end

data/lib/puppet/pops/loader/ruby_function_instantiator.rb

@@ -16,7 +16,10 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Functions\.create_function/
       raise ArgumentError, "The code loaded from #{source_ref} does not seem to be a Puppet 4x API function - no create_function call."
     end
-    created = eval(ruby_code_string, nil, source_ref, 1)
+    # make the private loader available in a binding to allow it to be passed on
+    loader_for_function = loader.private_loader
+    here = get_binding(loader_for_function)
+    created = eval(ruby_code_string, here, source_ref, 1)
     unless created.is_a?(Class)
       raise ArgumentError, "The code loaded from #{source_ref} did not produce a Function class when evaluated. Got '#{created.class}'"
     end
@@ -27,8 +30,18 @@ class Puppet::Pops::Loader::RubyFunctionInstantiator
     # when calling functions etc.
     # It should be bound to global scope
 
-    # TODO: Cheating wrt. scope - assuming it is found in the context
+    # Cheating wrt. scope - assuming it is found in the context (else an empty hash is used).
     closure_scope = Puppet.lookup(:global_scope) { {} }
-    created.new(closure_scope, loader.private_loader)
+    # If function definition used the loader from the binding to create a new loader, that loader wins
+    created.new(closure_scope, loader_for_function)
+  end
+
+  private
+
+  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
+  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
+  #
+  def self.get_binding(loader_injected_arg)
+    binding
   end
 end

data/lib/puppet/pops/loader/type_definition_instantiator.rb

@@ -0,0 +1,55 @@
+# The TypeDefinitionInstantiator instantiates a type alias or a type definition
+#
+module Puppet::Pops
+module Loader
+class TypeDefinitionInstantiator
+  def self.create(loader, typed_name, source_ref, pp_code_string)
+    # parse and validate
+    parser = Parser::EvaluatingParser.new()
+    model = parser.parse_string(pp_code_string, source_ref).model
+    # Only one type is allowed (and no other definitions)
+
+    name = typed_name.name
+    case model.definitions.size
+    when 0
+      raise ArgumentError, "The code loaded from #{source_ref} does not define the type '#{name}' - it is empty."
+    when 1
+      # ok
+    else
+      raise ArgumentError,
+        "The code loaded from #{source_ref} must contain only the type '#{name}' - it has additional definitions."
+    end
+    type_definition = model.definitions[0]
+
+    unless type_definition.is_a?(Model::TypeAlias) || type_definition.is_a?(Model::TypeDefinition)
+      raise ArgumentError,
+        "The code loaded from #{source_ref} does not define the type '#{name}' - no type alias or type definition found."
+    end
+
+    actual_name = type_definition.name
+    unless name == actual_name.downcase
+      raise ArgumentError,
+        "The code loaded from #{source_ref} produced type with the wrong name, expected '#{name}', actual '#{actual_name}'"
+    end
+
+    unless model.body == type_definition
+      raise ArgumentError,
+        "The code loaded from #{source_ref} contains additional logic - can only contain the type '#{name}'"
+    end
+
+    # Adapt the type definition with loader - this is used from logic contained in its body to find the
+    # loader to use when resolving contained aliases API. Such logic have a hard time finding the closure (where
+    # the loader is known - hence this mechanism
+    private_loader = loader.private_loader
+    Adapters::LoaderAdapter.adapt(type_definition).loader = private_loader
+
+    Types::PTypeAliasType.new(name, type_definition.type_expr)
+  end
+
+  def self.create_from_model(type_definition, loader)
+    name = type_definition.name
+    [Loader::TypedName.new(:type, name.downcase), Types::PTypeAliasType.new(name, type_definition.type_expr)]
+  end
+end
+end
+end

data/lib/puppet/pops/loaders.rb

@@ -1,4 +1,5 @@
-class Puppet::Pops::Loaders
+module Puppet::Pops
+class Loaders
   class LoaderError < Puppet::Error; end
 
   attr_reader :static_loader
@@ -8,7 +9,7 @@ class Puppet::Pops::Loaders
 
   def initialize(environment)
     # The static loader can only be changed after a reboot
-    @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
+    @@static_loader ||= Loader::StaticLoader.new()
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
@@ -35,6 +36,46 @@ class Puppet::Pops::Loaders
     @puppet_system_loader = nil
   end
 
+  # Finds the `Loaders` instance by looking up the :loaders in the global Puppet context and then uses it to
+  # find the appropriate loader for the given `module_name`, or for the environment in case `module_name`
+  # is `nil` or empty.
+  #
+  # @param module_name [String,nil] the name of the module
+  # @return [Loader::Loader] the found loader
+  # @raise [Puppet::ParseError] if no loader can be found
+  # @api private
+  def self.find_loader(module_name)
+    loaders = Puppet.lookup(:loaders) { nil }
+    raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing" if loaders.nil?
+    loaders.find_loader(module_name)
+  end
+
+  # Finds the appropriate loader for the given `module_name`, or for the environment in case `module_name`
+  # is `nil` or empty.
+  #
+  # @param module_name [String,nil] the name of the module
+  # @return [Loader::Loader] the found loader
+  # @raise [Puppet::ParseError] if no loader can be found
+  # @api private
+  def find_loader(module_name)
+    if module_name.nil? || module_name == ''
+      # TODO : Later when fdefinition can be private, a decision is needed regarding what that means.
+      #        A private environment loader could be used for logic outside of modules, then only that logic
+      #        would see the definition.
+      #
+      # Use the private loader, this definition may see the environment's dependencies (currently, all modules)
+      loader = private_environment_loader()
+      raise Puppet::ParseError, 'Internal Error: did not find public loader' if loader.nil?
+      loader
+    else
+      # TODO : Later check if definition is private, and then add it to private_loader_for_module
+      #
+      loader = public_loader_for_module(module_name)
+      raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{module_name}'" if loader.nil?
+      loader
+    end
+  end
+
   def static_loader
     @@static_loader
   end
@@ -66,7 +107,7 @@ class Puppet::Pops::Loaders
   private
 
   def create_puppet_system_loader()
-    Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
+    Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   def create_environment_loader(environment)
@@ -91,10 +132,10 @@ class Puppet::Pops::Loaders
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
+      loader = Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
-      loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
+      loader = Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
@@ -105,7 +146,7 @@ class Puppet::Pops::Loaders
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
-    loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
+    loader = Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.
@@ -121,7 +162,7 @@ class Puppet::Pops::Loaders
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
-      md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
+      md.public_loader = Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest
@@ -224,7 +265,7 @@ class Puppet::Pops::Loaders
     def create_loader_with_all_modules_visible(from_module_data)
       Puppet.debug{"ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible"}
 
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
+      Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
     end
 
     def create_loader_with_only_dependencies_visible(from_module_data)
@@ -234,7 +275,8 @@ class Puppet::Pops::Loaders
           " Use 'puppet module list --tree' to see information about modules")
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
-      Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
+      Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
     end
   end
 end
+end

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

@@ -28,7 +28,8 @@ module Puppet::Pops::Lookup
   end
 
   class ExplainTreeNode < ExplainNode
-    attr_reader :parent, :event, :key, :value
+    attr_reader :parent, :event, :value
+    attr_accessor :key
 
     def initialize(parent)
       @parent = parent
@@ -133,6 +134,55 @@ module Puppet::Pops::Lookup
     end
   end
 
+  class ExplainTop < ExplainTreeNode
+    def initialize(parent, type, key)
+      super(parent)
+      @type = type
+      self.key = key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Searching for "' << key << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+    end
+  end
+
+  class ExplainInvalidKey < ExplainTreeNode
+    def initialize(parent, key)
+      super(parent)
+      @key = key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << "Invalid key \"" << @key << "\"\n"
+    end
+
+    def type
+      :invalid_key
+    end
+  end
+
+  class ExplainMergeSource < ExplainNode
+    attr_reader :merge_source
+
+    def initialize(merge_source)
+      @merge_source = merge_source
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Using merge options from "' << merge_source << "\" hash\n"
+    end
+
+    def to_hash
+      { :type => type, :merge_source => merge_source }
+    end
+
+    def type
+      :merge_source
+    end
+  end
+
   class ExplainInterpolate < ExplainTreeNode
     def initialize(parent, expression)
       super(parent)
@@ -163,6 +213,8 @@ module Puppet::Pops::Lookup
     end
 
     def dump_on(io, indent, first_indent)
+      return if branches.size == 0
+
       # It's pointless to report a merge where there's only one branch
       return branches[0].dump_on(io, indent, first_indent) if branches.size == 1
 
@@ -297,7 +349,7 @@ module Puppet::Pops::Lookup
     def dump_on(io, indent, first_indent)
       io << indent << 'Path "' << @path.path << "\"\n"
       indent = increase_indent(indent)
-      io << indent << 'Original path: ' << @path.original_path << "\n"
+      io << indent << 'Original path: "' << @path.original_path << "\"\n"
       branches.each {|b| b.dump_on(io, indent, indent)}
       io << indent << "Path not found\n" if @event == :path_not_found
       dump_outcome(io, indent)
@@ -332,8 +384,10 @@ module Puppet::Pops::Lookup
   end
 
   class Explainer < ExplainNode
-    def initialize
+    def initialize(explain_options = false, only_explain_options = false)
       @current = self
+      @explain_options = explain_options
+      @only_explain_options = only_explain_options
     end
 
     def push(qualifier_type, qualifier)
@@ -352,6 +406,10 @@ module Puppet::Pops::Lookup
           ExplainMerge.new(@current, qualifier)
         when :scope
           ExplainScope.new(@current)
+        when :meta, :data
+          ExplainTop.new(@current, qualifier_type, qualifier)
+        when :invalid_key
+          ExplainInvalidKey.new(@current, qualifier)
         else
           raise ArgumentError, "Unknown Explain type #{qualifier_type}"
         end
@@ -359,6 +417,14 @@ module Puppet::Pops::Lookup
       @current = node
     end
 
+    def only_explain_options?
+      @only_explain_options
+    end
+
+    def explain_options?
+      @explain_options
+    end
+
     def pop
       @current = @current.parent unless @current.parent.nil?
     end
@@ -375,6 +441,10 @@ module Puppet::Pops::Lookup
       @current.found(key, value)
     end
 
+    def accept_merge_source(merge_source)
+      @current.branches << ExplainMergeSource.new(merge_source)
+    end
+
     def accept_not_found(key)
       @current.not_found(key)
     end

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

@@ -1,6 +1,7 @@
 module Puppet::Pops::Lookup
   class Invocation
-    attr_reader :scope, :override_values, :default_values, :explainer, :module_name
+    attr_reader :scope, :override_values, :default_values, :explainer
+    attr_accessor :module_name, :top_key
 
     # 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
@@ -50,34 +51,31 @@ module Puppet::Pops::Lookup
     # :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 name of a module or nil if that's not applicable
+    # :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)
-      is_meta = qualifier_type == :meta
-      @module_name = qualifier if is_meta
       if @explainer.nil?
         yield
       else
-        if is_meta
-          save_explainer = @explainer
-          @explainer = nil
-          begin
-            yield
-          ensure
-            @explainer = save_explainer
-          end
-        else
-          @explainer.push(qualifier_type, qualifier)
-          begin
-            yield
-          ensure
-            @explainer.pop
-          end
+        @explainer.push(qualifier_type, qualifier)
+        begin
+          yield
+        ensure
+          @explainer.pop
         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
@@ -93,6 +91,10 @@ module Puppet::Pops::Lookup
       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

data/lib/puppet/pops/lookup.rb

@@ -1,32 +1,36 @@
 # This class is the backing implementation of the Puppet function 'lookup'.
 # See puppet/functions/lookup.rb for documentation.
 #
-module Puppet::Pops::Lookup
+module Puppet::Pops
+module Lookup
+  LOOKUP_OPTIONS = 'lookup_options'.freeze
+  GLOBAL = '__global__'.freeze
+
   # Performs a lookup in the configured scopes and optionally merges the default.
   #
   # This is a backing function and all parameters are assumed to have been type checked.
   # See puppet/functions/lookup.rb for full documentation and all parameter combinations.
   #
   # @param name [String|Array<String>] The name or names to lookup
-  # @param type [Puppet::Pops::Types::PAnyType|nil] The expected type of the found value
+  # @param type [Types::PAnyType|nil] The expected type of the found value
   # @param default_value [Object] The value to use as default when no value is found
   # @param has_default [Boolean] Set to _true_ if _default_value_ is included (_nil_ is a valid _default_value_)
-  # @param merge [Puppet::Pops::MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
-  # @param lookup_invocation [Puppet::Pops::Lookup::Invocation] Invocation data containing scope, overrides, and defaults
+  # @param merge [MergeStrategy,String,Hash<String,Object>,nil] Merge strategy or hash with strategy and options
+  # @param lookup_invocation [Invocation] Invocation data containing scope, overrides, and defaults
   # @return [Object] The found value
   #
   def self.lookup(name, value_type, default_value, has_default, merge, lookup_invocation)
-    value_type = Puppet::Pops::Types::PDataType::DEFAULT if value_type.nil?
+    value_type = Types::PDataType::DEFAULT if value_type.nil?
     names = name.is_a?(Array) ? name : [name]
 
     # find first name that yields a non-nil result and wrap it in a two element array
     # with name and value.
-    not_found = Puppet::Pops::MergeStrategy::NOT_FOUND
+    not_found = MergeStrategy::NOT_FOUND
     override_values = lookup_invocation.override_values
     result_with_name = names.reduce([nil, not_found]) do |memo, key|
-      value = override_values.include?(key) ? assert_type('override', value_type, override_values[key]) : not_found
+      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) } if value.equal?(not_found)
-      break [key, assert_type('found', value_type, value)] unless value.equal?(not_found)
+      break [key, assert_type('Found value', value_type, value)] unless value.equal?(not_found)
       memo
     end
 
@@ -35,7 +39,7 @@ module Puppet::Pops::Lookup
       default_values = lookup_invocation.default_values
       unless default_values.empty?
         result_with_name = names.reduce(result_with_name) do |memo, key|
-          value = default_values.include?(key) ? assert_type('default_values_hash', value_type, default_values[key]) : not_found
+          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
@@ -46,9 +50,9 @@ module Puppet::Pops::Lookup
     answer = result_with_name[1]
     if answer.equal?(not_found)
       if block_given?
-        answer = assert_type('default_block', value_type, yield(name))
+        answer = assert_type('Value returned from default block', value_type, yield(name))
       elsif has_default
-        answer = assert_type('default_value', value_type, default_value)
+        answer = assert_type('Default value', value_type, default_value)
       else
         fail_lookup(names)
       end
@@ -62,7 +66,7 @@ module Puppet::Pops::Lookup
   end
 
   def self.assert_type(subject, type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(subject, type, value)
+    Types::TypeAsserter.assert_instance_of(subject, type, value)
   end
   private_class_method :assert_type
 
@@ -72,3 +76,4 @@ module Puppet::Pops::Lookup
   end
   private_class_method :fail_lookup
 end
+end